🦥 SlothOS AI — Work Less, Live More: A Privacy-First Productivity Assistant Powered by Local Gemma 3

🦥 SlothOS AI — Work Less, Live More! | A Local AI Productivity Assistant

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

What I Built

🦥 Meet SlothOS AI — Your AI-Powered Productivity Companion!

What if being lazy could actually make you more productive?

We spend a surprising amount of time doing repetitive digital tasks: organizing files, reading lengthy documents, creating task lists, and figuring out what to do next.

These activities are important, but they shouldn’t require so much manual effort.

That’s why I built SlothOS AI, a privacy-conscious, local-first productivity assistant powered by Gemma 3 (1B) through Ollama.

SlothOS brings multiple AI-powered productivity tools into a single dashboard, helping users automate everyday tasks without depending on a paid cloud AI API.

The philosophy behind the project is simple:

🦥 Work Less. Live More. Let AI Handle the Boring Stuff!

🎯 The Problem I’m Solving

Students, developers, and professionals regularly face repetitive tasks:

• 📂 Manually organizing files and documents.
• 📄 Reading lengthy PDFs to identify important information.
• 📝 Converting unstructured notes into actionable tasks.
• ⏰ Deciding which tasks should be prioritized.
• 🔄 Switching between multiple productivity applications.

These activities take time away from learning, creativity, and meaningful work.

SlothOS AI aims to reduce that busywork through local AI automation.

🚀 Key Features

🗂️ 1. Smart File Organizer — Say Goodbye to Digital Clutter!

Have you ever opened your Downloads folder and wondered how it became so messy?

SlothOS AI helps users organize uploaded files through AI-powered classification.

How it works:

1. Upload files to SlothOS.
2. The backend analyzes the files.
3. Gemma 3 suggests appropriate categories.
4. Preview the organization suggestions.
5. Apply the organization to local file copies.

Example:

Before:

Downloads/
├── notes.pdf
├── assignment.py
├── screenshot.png
├── project_report.pdf
└── tasks.txt

After:

Organized/
├── Documents/
│ └── project_report.pdf
├── Study Materials/
│ └── notes.pdf
├── Programming/
│ └── assignment.py
├── Images/
│ └── screenshot.png
└── Other/
└── tasks.txt

These categories illustrate the intended workflow; actual suggestions depend on AI classification.

🦥 Lazy Benefit: Less manual file sorting and a cleaner digital workspace.

📄 2. AI Document Summarizer — Read Less, Understand More!

Reading lengthy documents can be time-consuming, especially when you’re only looking for important information.

SlothOS AI uses local AI to generate concise summaries of text-based PDF documents.

How it works:

1. Upload a PDF document.
2. PyMuPDF extracts the text.
3. FastAPI sends the relevant text to Gemma 3 through Ollama.
4. The model generates a summary.
5. SlothOS displays the result.

What it helps with:

• Understanding lecture notes.
• Reviewing project documentation.
• Summarizing technical reports.
• Identifying important concepts.

🦥 Lazy Benefit: Spend less time searching through documents and more time understanding their contents.

🧠 3. Lazy Task Planner — Turn Chaos into Clarity!

Sometimes the hardest part of being productive is figuring out where to begin.

The Lazy Task Planner converts natural-language notes into structured tasks with suggested priorities.

Example input:

I need to complete my Python assignment, prepare for my robotics interview, finish my presentation, and revise mathematics.

Example output:

Task Priority
Prepare for robotics interview 🔴 High
Complete presentation 🔴 High
Finish Python assignment 🟡 Medium
Revise mathematics 🟡 Medium

The priorities are suggestions generated by the model.

🦥 Lazy Benefit: Less time manually creating and prioritizing task lists.

🦥 4. Sloth Mode — One Click, Multiple Insights!

Sloth Mode is the feature that best represents the theme of this challenge.

Instead of manually reading a document, summarizing it, identifying tasks, and deciding what to do next, users can upload a PDF and request multiple AI-generated insights.

Sloth Mode is designed to provide:

• 📄 A concise document summary.
• ✅ Important action items.
• 🎯 Suggested priorities.
• 🚀 Recommended next steps.

One document. One workflow. Multiple useful insights.

🦥 Lazy Benefit: Reduce the repetitive analysis required to turn information into action.

👥 Who Can Benefit?

🎓 Students: Summarize study materials, organize assignments, and plan tasks.

💻 Developers: Organize files, review documentation, and structure development work.

👨‍💼 Professionals: Summarize reports, identify action items, and organize daily activities.

🦥 Everyone Else: Spend less time managing digital clutter.

⸻

Demo

📸 SlothOS AI — Application Screenshots

SlothOS AI currently runs locally using React, FastAPI, Ollama, and Gemma 3.

Instead of a deployed demo or video, I’m sharing screenshots of the application along with the GitHub repository, which includes instructions for running it locally.

🖥️ 1. Main Dashboard

The SlothOS dashboard provides a central interface for accessing the AI-powered productivity tools.

It also displays the connection status of the local AI backend.

📄 2. AI Document Summarizer

The Document Summarizer allows users to upload text-based PDFs and generate summaries using local AI.

🗂️ 3. Smart File Organizer

The Smart File Organizer provides AI-generated file categories and a preview of the proposed organization.

🧠 4. Lazy Task Planner

The Lazy Task Planner converts unstructured notes into actionable tasks with suggested priorities.

🦥 5. Sloth Mode

Sloth Mode analyzes PDF documents to generate summaries, action items, and suggested priorities.

🔗 Explore the Project

GitHub Repository: SlothOS AI — Source Code and Setup Instructions

The repository contains the project code, installation instructions, and technical documentation.

⸻

Code

💻 SlothOS AI — GitHub Repository

🔗 View SlothOS AI on GitHub

SlothOS AI is built using a React frontend, a Python FastAPI backend, and Gemma 3 running locally through Ollama.

📂 Project Structure

SlothOS-AI/
│
├── backend/
│ ├── main.py
│ ├── requirements.txt
│ └── workspace/
│
├── frontend/
│ ├── public/
│ ├── src/
│ │ ├── App.jsx
│ │ ├── index.css
│ │ └── main.jsx
│ ├── package.json
│ └── vite.config.js
│
├── .gitignore
└── README.md

⚡ Run SlothOS AI Locally

Step 1: Clone the repository

git clone https://github.com/sandeepji11/SlothOS-AI.git
cd SlothOS-AI

Step 2: Install the AI model

Install Ollama, then run:

ollama pull gemma3:1b

Make sure Ollama is running.

Step 3: Start the backend

cd backend
python3 -m venv venv
source venv/bin/activate
python -m pip install -r requirements.txt
python -m uvicorn main:app --reload --host 127.0.0.1 --port 8000

Step 4: Start the frontend

Open another terminal from the project root:

cd frontend
npm install
npm run dev -- --port 5175

Step 5: Open SlothOS AI

Visit:

http://localhost:5175

The complete setup instructions are available in the GitHub README.

⸻

How I Built It

🧠 Building a Local-First AI Productivity Assistant

For this project, I wanted to explore how open-weight AI models could power useful productivity applications without relying on a cloud-based language model API.

I selected Gemma 3 (1B) and used Ollama to run the model locally.

The application is divided into three main components:

1. React Frontend: Provides the interactive dashboard and productivity tools.

2. FastAPI Backend: Handles document processing, file operations, API requests, and communication with the AI model.

3. Ollama + Gemma 3: Performs local AI inference for summarization, classification, task extraction, and document analysis.

🏗️ System Architecture

              👤 USER
                 |
                 v
         🖥️ React Dashboard
                 |
                 v
         ⚙️ FastAPI Backend
                 |
      +----------+----------+
      |          |          |
      v          v          v
  File Tools   PDF Tools  Task Tools
      |          |          |
      +----------+----------+
                 |
                 v
           🤖 Ollama
                 |
                 v
         🧠 Gemma 3 (1B)
                 |
                 v
          AI-Generated
             Results
                 |
                 v
         🖥️ React Dashboard

🛠️ Technology Stack

Technology Purpose
React Frontend dashboard
Vite Frontend development
Tailwind CSS Interface styling
Lucide React UI icons
Axios API communication
Python Backend processing
FastAPI REST API
Ollama Local AI inference
Gemma 3 (1B) AI language processing
PyMuPDF PDF text extraction
GitHub Source code and collaboration

⚙️ How It Works

Step 1 — User Input

Users upload files, submit PDFs, or enter natural-language notes through the React interface.

Step 2 — Backend Processing

FastAPI receives the request and prepares the information for processing.

For PDF documents, PyMuPDF extracts the text.

For file organization, the backend analyzes uploaded files and prepares classification information.

Step 3 — Local AI Inference

FastAPI communicates with Ollama, which runs Gemma 3 locally.

The model processes the input and generates a response.

Step 4 — Structured Results

The backend returns the AI-generated information to the frontend.

Step 5 — User Review

The user reviews the generated summary, task list, or organization suggestions.

💡 Why I Chose Gemma 3 (1B)

I wanted a relatively lightweight model that could run locally and support practical AI workflows.

Gemma 3 (1B) allowed me to experiment with:

• Local text generation.
• Document summarization.
• Natural-language task extraction.
• AI-powered file classification.
• Structured document insights.

Using a smaller model also introduces limitations, including response quality and context constraints. Those trade-offs are part of what I wanted to explore through this project.

🧩 Challenges During Development

One challenge was integrating the React frontend with the Python FastAPI backend.

Because both applications run on different local ports, I needed to configure the API communication and CORS settings correctly.

Another challenge was integrating the local Gemma model through Ollama and ensuring the backend could detect whether the model was available.

I also had to handle PDF text extraction, file uploads, and AI-generated responses in a way that made sense for each productivity feature.

Working through these challenges helped me understand how to build an AI-powered full-stack application around local inference.

⸻

Why Does Open Innovation Matter?

🔓 Making AI More Accessible, Private, and Customizable

Open innovation played a central role in building SlothOS AI.

I wanted to create an application where AI processing could happen on the user’s computer rather than requiring every request to be sent to a remote service.

Using Gemma 3 through Ollama made this possible.

🔒 1. Greater Control Over Privacy

SlothOS processes AI requests locally.

This means documents can be analyzed without sending their contents to an external AI inference provider.

For an application designed to handle notes, assignments, and personal documents, this is an important advantage.

Local processing doesn’t guarantee complete security, but it reduces dependency on external AI services.

🌐 2. Offline AI Capabilities

Once Ollama and Gemma 3 are installed, the core AI features can operate without an internet connection.

This makes local-first AI applications useful in environments with limited connectivity.

💰 3. Reduced API Costs

Local inference avoids recurring per-request cloud AI fees.

For students and independent developers, this can make experimentation more accessible.

The trade-off is that the model uses local computing resources.

🛠️ 4. Freedom to Experiment

Using a locally running model allows me to experiment with prompts, model configurations, and application workflows.

I can modify how SlothOS processes documents, generates tasks, or classifies files without depending on a proprietary cloud AI endpoint.

🤝 5. Community Collaboration

By publishing the project on GitHub, I can share the implementation, receive feedback, and welcome contributions.

Developers can explore the architecture and suggest improvements.

🌍 Why This Matters to Me

I believe useful AI tools should be approachable for students, developers, and people who want more control over their applications.

Not every AI project needs a large cloud-hosted model.

Sometimes, a smaller local model can be a useful starting point for solving everyday problems.

SlothOS AI is my attempt to demonstrate that idea through practical productivity workflows.

Note: Gemma is an open-weight model distributed under its own terms, rather than under a conventional open-source software license.

⸻

The Lazy Payoff

🦥 Less Busywork. More Meaningful Work.

The goal of SlothOS AI is not to eliminate work.

It’s to reduce repetitive activities that consume time and attention.

Here’s how the application is designed to help:

Task Traditional Approach SlothOS Approach
Organizing files Manually inspect and sort files AI-generated categories and organization
Summarizing PDFs Read and manually identify key points AI-generated document summaries
Planning tasks Manually structure and prioritize notes AI-generated tasks and priorities
Reviewing documents Summarize and identify next steps separately Sloth Mode combines multiple insights

🎯 What Makes It Lazy?

SlothOS reduces the number of manual steps required to organize information.

Instead of switching between different tools, users can access multiple AI-powered productivity features from one dashboard.

The project is designed to help students spend more time learning, developers spend more time building, and professionals spend less time on repetitive document processing.

I haven’t measured exact time savings yet, so I don’t want to claim an unsupported percentage or number of hours saved.

However, the workflows demonstrate how local AI can reduce repetitive steps.

💡 My Biggest Takeaway

The best productivity tools don’t just help us do more. They help us spend less effort on repetitive tasks.

That is the kind of laziness I wanted to reward.

⸻

Final Thoughts

🦥 Work Less. Live More.

Hacktoberfest Week 3 challenged developers to build something that rewards laziness.

I interpreted that challenge as an opportunity to simplify everyday digital workflows using local AI.

Through SlothOS AI, I explored how Gemma 3, Ollama, React, and FastAPI could work together to build a productivity assistant that supports file organization, document summarization, task planning, and document analysis.

This project also helped me learn more about full-stack development, local AI inference, and the practical trade-offs of smaller language models.

SlothOS is still an evolving project, and I plan to continue improving its functionality, reliability, and user experience.

🚀 What’s Next?

Future improvements include:

• Support for larger PDFs.
• Persistent task storage.
• More flexible file organization.
• Support for additional local AI models.
• Improved automation workflows.
• Better error handling and testing.
• A possible desktop application.

⭐ Explore SlothOS AI

GitHub Repository: SlothOS AI

Built by: Sandeep Verma

Challenge: Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady

Thanks for reading!

If you find SlothOS AI interesting, feel free to explore the repository, share feedback, or suggest improvements.

🦥 Work Less. Live More.