MAX：本機優先、由 Gemma 2 2B 驅動的生產力桌面應用程式

"Meet MAX, a desktop productivity companion combining tasks, goals, habits, focus, and evidence-grounded AI coaching with local Gemma 2 2B inference."

tags: hacktoberfest, productivity, ai, opensource

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

My productivity workflow had become fragmented.

Tasks lived in one application, long-term goals in a spreadsheet, habits in another app, and focus sessions in a separate timer. When I needed advice about my progress, I had to piece everything together myself—or turn to a cloud AI tool.

I wanted something different: one productivity workspace that connects daily execution with long-term goals and provides AI coaching without depending on a remote LLM API.

So I built MAX, a local-first productivity desktop application designed for students, developers, freelancers, and independent builders.

Four pillars of productivity

1. Tasks & Subtasks

• Kanban and list-based task management.
• Cognitive energy ratings to help organize work.
• Recurring tasks and task history.
• Task status and progress tracking.

2. Goals & Projects

• Manage short-term and long-term goals.
• Break goals into milestones.
• Track progress through milestone completion.

3. Habits & Focus

• Track daily habits and streaks.
• Use a built-in Pomodoro timer or stopwatch.
• Associate focus sessions with tasks and record elapsed time.

4. Insights & Reflection

• Visualize workload trends over the last seven days.
• Compare planned and actual task duration.
• Track blockers and write daily reflections.

The AI Coach: More than a chatbot

The most interesting part of MAX is its AI Coach, powered by Google's Gemma 2 2B instruction-tuned model through Ollama.

Rather than asking the model to invent productivity statistics, MAX gathers available evidence from its local SQLite database first. The coach can use supported task and productivity metrics to help identify planning problems, discuss priorities, and suggest improvements.

Its key interaction pattern is Review & Apply:

1. MAX gathers relevant productivity evidence.
2. The AI generates an explanation or recommendation.
3. The user reviews the proposed change.
4. The user decides whether to apply or dismiss it.

The AI is there to assist decision-making—not silently take control of the user's data.

[Insert screenshot: AI Coach diagnosis with evidence and recommendations]

Who is MAX for?

MAX is designed for people managing ambitious goals alongside everyday responsibilities: students preparing for exams, developers building side projects, freelancers balancing client work, and solo founders trying to stay consistent.

The longer-term opportunity is a productivity companion that offers useful personalization without making a recurring cloud AI subscription a prerequisite.

Demo

MAX is a desktop application, so I'm sharing screenshots of the actual application running locally rather than a hosted web demo.

Home Dashboard

Tasks & Kanban

Local AI Diagnosis

Human-in-the-Loop Recommendations

AI Onboarding

These screenshots show the implemented interface and the intended local AI workflow.

Run MAX locally

Source code: MAX on GitHub

If you're using Windows and have the required development tools installed:

git clone https://github.com/YUVA56-gomu/MAX---Boost-Your-Self-Productiviy.git
cd MAX---Boost-Your-Self-Productiviy
powershell -ExecutionPolicy Bypass -File scripts\start-dev.ps1

Check the repository README for prerequisites and the latest setup instructions. The development script starts the local frontend and backend; this is a development workflow, not a packaged production installer.

Code

MAX is open source under the MIT License.

MAX — Boost Your Self-Productivity

MAX is a sovereign, local-first adaptive productivity desktop application built for deep work, goal achievement, habit compounding, and behavioral reflection.

Built with Tauri 2 (Rust), React 19, TypeScript, FastAPI (Python 3.14), SQLite WAL, and powered by an optional 100% offline local AI Coach (Ollama + Gemma 2 2B).

1. What MAX Is & The Problem It Solves

Modern knowledge workers and independent builders juggle disconnected tools: one for tasks, another for habit streaks, a timer for Pomodoro sessions, a spreadsheet for high-level goals, and cloud-hosted AI subscriptions that extract telemetry and expose sensitive personal priorities.

MAX unifies personal execution into a single, cohesive, high-density environment governed by three non-negotiable principles:

1. Absolute Sovereignty & Privacy: All personal data stays on your local machine in an ACID-compliant SQLite database. Zero external network calls, zero tracking telemetry, and zero mandatory cloud…

The main technologies are:

• Desktop shell: Tauri 2
• Frontend: React 19, TypeScript, Vite, Tailwind CSS v4, and shadcn/ui
• Backend: Python, FastAPI, SQLAlchemy, and Alembic
• Database: SQLite with Write-Ahead Logging
• Local AI: Ollama with Gemma 2 2B
• Testing: Vitest and Pytest

The frontend, backend, persistence layer, and AI services are separated so that the core productivity experience remains useful even when the AI service is unavailable.

How I Built It

1. Open-weight AI with Ollama and Gemma 2 2B

I chose Gemma 2 2B because I wanted to explore useful AI assistance on consumer hardware rather than build the product around a remote inference API.

Ollama provides the local model runtime, while the FastAPI backend coordinates AI requests and the productivity data used to ground them.

Inference time depends on hardware, model state, and the request. The model can require an initial download, and Ollama must be installed and available for AI features to work.

2. Evidence before generation

A productivity coach is only useful if it understands the user's actual situation.

Before generating a diagnosis, MAX queries its local SQLite data for relevant metrics, such as active and completed tasks and available duration estimates. These facts provide context for the model's recommendations.

This approach helps distinguish observed application data from AI-generated interpretation. The model can still make mistakes, so recommendations remain reviewable.

3. User approval before changes

AI-generated recommendations should not automatically rewrite someone's plans.

MAX uses an explicit review workflow so users can inspect a proposal before deciding whether to apply or dismiss it. This keeps the user involved in the decision-making process.

4. Local persistence and application boundaries

SQLite stores persistent productivity data, with Write-Ahead Logging enabled for database operation.

The desktop architecture also includes a backend authentication mechanism designed to keep its token in application memory rather than browser storage. The aim is to make the boundaries between the frontend, backend, local data, and AI runtime explicit.

5. Guided AI onboarding

Local AI introduces its own setup challenges. Ollama may not be installed, the service may not be running, or the configured model may be missing.

MAX includes an onboarding flow that checks these states, guides the user through setup, verifies inference, and allows the user to continue without enabling AI.

Installing Ollama and downloading Gemma may require internet access. MAX's focus is local-first persistence and local model inference—not an unverified promise that every operation generates zero network traffic.

Why Does Open Innovation Matter?

Open innovation made it possible to explore a different trade-off between useful AI assistance, accessibility, and control over personal data.

If MAX depended entirely on a proprietary cloud inference API, users could face recurring usage costs and would need to send AI requests to an external service. The application would also depend on that provider's pricing, availability, and API changes.

Using an open-weight model such as Gemma 2 2B gives developers another option: run inference locally, experiment with the model, and build application-specific workflows around it.

Combining local inference with open-source tools such as Ollama, FastAPI, React, SQLite, and Tauri makes the architecture more accessible to inspect, adapt, and extend.

There are trade-offs. Small models have capability limits, local inference depends on available hardware, and a local-first design still requires careful security and network testing.

For me, open innovation is about making these trade-offs choices developers can explore—not decisions imposed by a single cloud provider.

My Agent Session

I built MAX with assistance from Google's Antigravity coding agent.

The development workflow focused on incremental implementation, automated testing, and browser-based verification. The agent helped with implementation and debugging, while I directed the product requirements and evaluated the resulting application.

The project currently reports 126 passing automated tests: 71 frontend tests and 55 backend tests. These results reflect the test suites run during development; they are not a substitute for independent security or performance validation.

My First User

I was my own first user.

During the Hacktoberfest sprint, I used MAX to organize the development work itself. I tracked engineering milestones in the Tasks Canvas and used focus sessions to structure work blocks.

I also tried the AI diagnosis against the application's available sprint data. It highlighted a potential mismatch between active tasks and recorded focus time and suggested reviewing the estimates for upcoming work.

That experience captured the idea behind MAX: use the same productivity system you're building to manage the work of building it, then let the AI help you reflect on the evidence.

Prize Categories

Primary submission: Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

I'll only claim additional partner or showcase categories where the published challenge rules confirm eligibility.

What's Next?

MAX is a working prototype, and there is plenty more to explore: improving coaching quality, evaluating recommendations against longer-term usage, strengthening onboarding, and gathering feedback from real users.

The goal is simple: build a productivity companion that helps people understand their work and make better decisions, while keeping local-first AI a practical option.

If you're interested in local AI, developer tools, or productivity software, I'd love to hear what you think.

Explore the code, try it locally, and tell me what you'd improve.