SlothStack: Slow Down. Automate More. 🦥

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

What I Built

Meet SlothStack — a local-first AI productivity assistant designed to handle repetitive digital work so you can focus on what actually matters.

We spend too much time organizing files, searching through documents, tracking deadlines, renaming downloads, and turning scattered information into actionable tasks. These small jobs may seem harmless, but together they consume a surprising amount of time and attention.

SlothStack aims to make that busywork easier by using AI agents to help organize your digital workspace.

Here's what it is designed to do:

• 📂 Smart File Organization: Categorize documents and suggest meaningful filenames.
• ✅ Task Extraction: Identify action items, deadlines, and follow-ups from supported documents.
• 🔎 Duplicate Detection: Help identify potentially duplicated files and reduce clutter.
• 🧠 Action Planning: Turn unstructured information into clear, actionable next steps.
• 🛡️ Human-Approved Automation: Preview proposed file operations before approving changes.
• 🔒 Local-First AI: Use locally running open-weight models to keep document processing on your machine.

The goal is simple: less repetitive work, less context switching, and more time for meaningful work.

SlothStack is intended for students, developers, researchers, and anyone whose digital workspace has become a second job.

Demo

The ideal demo walks through one complete workflow:

1. Upload a sample document.
2. Let a locally running model analyze its contents.
3. Review extracted tasks and suggested file organization.
4. Preview the proposed actions.
5. Approve an action and inspect the activity log.

The important part isn't just generating an AI response. It's demonstrating how an AI agent can turn information into useful, reviewable actions.

Live Demo:https://frontend-seven-mocha-i9ejtz56kz.vercel.app

Code

PruthviRajG25 / Hacktoberfest-Week3

Sloth Stack is a local-first productivity workspace

Sloth Stack

Do less. Let your local AI handle the busywork.

Sloth Stack is a local-first productivity workspace that turns inbox exports documents, and visual notes into useful, reviewable work. Upload a mail export analyze it with Ollama, review extracted tasks and deadlines, then approve safe file actions. Your data stays in the local SQLite database and upload directory.

What it does

Workspace	Purpose
Dashboard	Content-grounded daily briefing, workload counters, and priorities
Files	Upload mail exports and documents, then start local AI analysis
Tasks	Review extracted mail tasks, complete them, or create custom deadline-aware todos
Action plans	Approve or reject safe proposed actions and use the interactive planning notebook
Activity	Inspect the local audit trail
Settings	Configure Ollama and open Gmail, WhatsApp Web, or Slack

Import a mailbox or message export

Download the safe demo file from frontend/public/sloth-stack-inbox-sample.txt upload it from Files, and select Analyze. The analyzer…

View on GitHub

GitHub Repository: .

SlothStack is being designed with open-source contributions in mind. The architecture separates the frontend, backend, AI integration, document processing, and safe action execution so contributors can improve individual components without needing to understand the entire codebase first.

Potential contribution areas include:

• Adding document parsers and file formats.
• Improving task extraction and categorization.
• Supporting additional Ollama-compatible models.
• Writing tests for agent workflows.
• Improving accessibility and the dashboard experience.
• Adding security checks and documentation.

The goal is to make SlothStack useful not just as a personal productivity tool, but as a project other developers can learn from and extend.

How I Built It

SlothStack is designed around a local-first architecture with a React frontend, a Python backend, and open-weight language models served through Ollama.

Technology stack

• Frontend: React, TypeScript, Vite, and Tailwind CSS.
• Backend: Python and FastAPI.
• Data Layer: SQLite, SQLAlchemy, and Alembic migrations.
• AI Inference: Ollama with locally running open-weight models.
• Validation: Pydantic for structured data and validated agent outputs.
• Testing: Pytest for backend tests and Vitest for frontend tests.

Rather than treating the AI as a chatbot that merely describes what to do, SlothStack is designed around controlled agent workflows.

For example, a document-processing workflow can:

1. Read an uploaded file in a supported format.
2. Extract its text using the appropriate parser.
3. Send relevant content to a locally running model.
4. Request structured results, such as categories, tasks, deadlines, and suggested actions.
5. Validate the model's response before using it.
6. Present the proposed action plan to the user.
7. Execute only explicitly approved operations.
8. Record the outcome in an activity log.

The supported document formats are intended to include TXT, Markdown, PDF, JSON, and CSV.

Safety is part of the architecture, not an afterthought. The model should not have unrestricted filesystem access or be allowed to execute arbitrary shell commands or Python code. File operations should be restricted to authorized directories, paths should be validated, and potentially destructive actions should require explicit approval.

SlothStack also aims to defend against prompt injection in document contents, enforce file-size limits, and handle invalid model outputs safely.

This design makes the agent more than a demo that works only with a carefully prepared prompt. It provides a foundation for repeatable workflows that users can inspect and control.

Why Does Open Innovation Matter?

A productivity assistant may handle personal notes, private documents, project plans, research, and other sensitive information. Sending all of that content to a remote AI service isn't always appropriate.

Open innovation makes a different approach possible.

With open-weight models and local inference, users can run supported models on their own machines, experiment with different models, and adapt SlothStack to their workflows without making a closed API the foundation of the entire product.

It also creates opportunities for community-driven development:

• Model Freedom: Experiment with different compatible models rather than being tied to one provider.
• Privacy-Conscious Processing: Keep inference local when using a locally configured model and local services.
• Transparency: Inspect the code, review how actions are performed, and improve security.
• Accessibility: Let contributors improve the application without requiring every feature to depend on a paid API.
• Community Ownership: Build new parsers, integrations, workflows, and tests together.

Local inference doesn't automatically guarantee security or privacy; the application, model configuration, and surrounding services still matter. But it gives users more control over where their information is processed.

For me, open source is about making useful automation more accessible, understandable, and adaptable.

The Lazy Payoff 🦥

The real payoff isn't having AI do everything. It's eliminating the small, repetitive tasks that interrupt our concentration throughout the day.

Imagine finishing a study session or a development task and having a clear list of follow-ups, useful filenames for your documents, and an organized workspace instead of another pile of downloads and notes.

That's the idea behind SlothStack:

Automate the boring parts. Keep humans in control. Make meaningful work easier to start.

I won't claim a specific number of minutes saved without measuring it. A meaningful next step is to compare the time needed to organize a representative set of documents manually against the time needed with SlothStack, including review and approval.

The best automation is not the one that performs the most actions. It's the one that removes unnecessary effort without creating more work to clean up afterward.