LazyFlow AI: Turning Messy Messages into Actionable Tasks with Gemma 3

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

What I Built

As a parent, I often receive school announcements containing several reminders, assignments, deadlines, and upcoming activities. Sometimes, a single notification includes multiple things that need attention, and keeping track of everything can become overwhelming.

This made me think about how often we receive similar messages in everyday life, whether it's a school announcement, a long workplace email, meeting notes, or a group message filled with instructions and reminders.

What if I could simply paste one of these messages and let AI identify the tasks instead of going through everything manually?

That's how the idea for LazyFlow AI came about.

LazyFlow AI is a simple, full-stack AI-powered task management application that transforms long, messy, or unstructured messages into clear, actionable tasks using Google's open-weight Gemma 3 4B model running locally through Ollama.

Instead of manually identifying each task, users can paste a message and let the AI extract the relevant action items, along with deadlines and priorities.

With LazyFlow AI, users can:

• Extract actionable tasks from emails, school announcements, meeting notes, and everyday messages.
• Identify deadlines and priorities from the message context.
• Organize tasks under AI-generated group headings.
• Edit, complete, or delete tasks.
• Select individual tasks or entire groups and save them into named collections.
• Track task completion progress.

Although school notifications inspired the idea, I wanted to build something useful for anyone dealing with lengthy messages containing multiple things to do.

The goal isn't to replace existing reminder or task management applications, but to make the step before task management easier: turning scattered information into organized tasks.

Demo

This short demo shows how LazyFlow AI transforms a school announcement containing multiple instructions and deadlines into organized tasks.

It demonstrates AI task extraction, priority and deadline identification, task completion, selective saving, editing tasks, and tracking progress within saved collections.

Code

LazyFlow AI is an open-source full-stack project built with React, Node.js, Express, and Gemma 3 running locally through Ollama.

The GitHub repository includes the source code, setup instructions, environment configuration example, and screenshots of the application.

GitHub Repository: LazyFlow AI

How I Built It

I built LazyFlow AI using the MERN-style full-stack approach I'm familiar with, but instead of using MongoDB, I chose browser localStorage to keep the application simple for this MVP.

Tech Stack

• Frontend: React, Vite, Tailwind CSS, React Router, and Lucide React
• Backend: Node.js and Express
• AI Model: Google's Gemma 3 4B
• Local Inference: Ollama
• Storage: Browser localStorage

Application Architecture

LazyFlow AI follows a simple full-stack architecture, with Gemma 3 running locally through Ollama.

flowchart TD
    A["User pastes a message"] --> B["React + Vite Frontend"]
    B -->|"HTTP Request"| C["Node.js + Express Backend"]
    C -->|"Prompt + Message"| D["Ollama + Gemma 3 4B"]
    D -->|"Structured JSON"| C
    C -->|"Validated Tasks"| B
    B --> E["Task Dashboard"]
    E --> F["Saved Collections"]
    E -.-> G["Browser localStorage"]
    F -.-> G

The React frontend handles user interactions and task management. The Express backend communicates with Ollama, where Gemma 3 extracts actionable tasks, deadlines, priorities, and group headings.

The generated tasks are validated and returned to the frontend, where users can organize and manage them. Dashboard tasks and saved collections are persisted using browser localStorage.

Integrating Gemma 3 with Ollama

I wanted to explore running an open-weight AI model locally rather than depending on a cloud-based AI API.

I downloaded Gemma 3 4B and ran it on my Mac using Ollama.

When a user pastes a message and clicks Generate Tasks, the React frontend sends the text to the Express backend.

The backend then communicates with Ollama's API, passing the user's message along with instructions for extracting actionable tasks.

I designed the prompt to return structured JSON containing:

• A meaningful heading for the message
• Task titles
• Deadlines, when available
• Task priorities
• An indication of whether a task needs clarification

The backend validates the response before returning the extracted tasks to the frontend.

If a message doesn't contain any actionable items, the application displays a notification instead of creating unnecessary tasks.

Building the Task Management Features

Once tasks are generated, users can edit, delete, or mark them as completed.

I also added task grouping so that messages are kept separate. Users can select individual tasks or an entire group and save them into named collections.

Each collection has its own task list and completion progress.

For this MVP, I used localStorage to persist tasks and collections across browser refreshes without introducing a database or authentication system.

Challenges and What I Learned

One challenge was getting the AI model to return predictable, structured output. I refined the prompt to help Gemma distinguish actionable instructions from general information and avoid inventing deadlines or priorities.

Another challenge involved duplicate-message detection.

Initially, I stored a history of every successfully processed message to prevent duplicate tasks. However, I realized this prevented users from processing the same message again, even after deleting or saving its tasks.

I improved this by checking whether tasks from the same message still exist on the Dashboard. This prevents unnecessary duplicates while allowing users to regenerate tasks after clearing them.

I also worked on handling task selection, saving only selected tasks, and keeping progress tracking separate between the Dashboard and saved collections.

Building LazyFlow AI helped me better understand local LLM integration, prompt design for structured output, validating AI responses, and managing state across different parts of a React application.

Why Does Open Innovation Matter?

One of the reasons I chose Gemma 3 for LazyFlow AI was to explore how open-weight AI models can be used in everyday applications without relying on a hosted AI service.

Using Gemma 3 4B with Ollama allowed me to download the model and run inference locally on my Mac. I could experiment with prompts, test different types of messages, and refine how the model extracts tasks without making requests to a paid cloud AI API.

Local inference also offers an important privacy advantage. Messages such as school announcements, personal reminders, or workplace emails can be processed on the user's own machine without needing to send their contents to an external AI provider.

Another benefit is flexibility. Because the model runs through Ollama, I can experiment with different supported models and adjust the extraction instructions as the application evolves.

Of course, running AI locally also has trade-offs. Users need suitable hardware, must install Ollama and download the model, and inference performance depends on their device.

For me, open innovation made it possible to explore AI integration more independently, understand how local inference works, and build a practical application around an openly available model.

LazyFlow AI is a small example of how open-weight AI can make everyday tasks easier while giving developers more control over how their applications use AI.

The Lazy Payoff

The biggest benefit of LazyFlow AI is reducing the manual effort involved in identifying tasks from lengthy messages.

For example, a school announcement might contain information about homework, excursion payments, consent forms, and upcoming activities. Normally, I would need to read through the message, identify each action item, check the deadlines, and manually organize everything.

With LazyFlow AI, I can paste the entire message and get a structured list of tasks, along with their deadlines and priorities, which I can then review, edit, and organize.

The same approach works for workplace emails, meeting notes, and other everyday messages.

I haven't measured the exact time saved yet, but the application helps reduce the effort spent going through lengthy messages, figuring out what needs to be done, and identifying when each task needs to be completed.

For me, the idea behind LazyFlow AI is simple: make it easier to understand and organize tasks from everyday messages, so we can spend less time figuring out what needs to be done and when.

Prize Categories

Best Use of Gemma

LazyFlow AI uses Google's Gemma 3 4B open-weight model, running locally through Ollama, as the core of its AI task extraction functionality.

Gemma analyzes unstructured messages and generates structured task data, including task titles, deadlines, priorities, and meaningful group headings.

The application demonstrates how Gemma can be integrated into a practical full-stack workflow to simplify everyday task management.