🦥 Sloth Organizer: Let AI Tidy Your Files While You Do Absolutely Nothing
This is my submission for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.
What if organizing your files didn’t mean spending an afternoon dragging documents between folders, renaming cryptic filenames, and trying to remember where everything belongs?
You could do it yourself. Or, like a sloth, you could conserve your energy and let AI do the heavy lifting. 🦥
Meet Sloth Organizer — a local-first AI application that scans messy folders, proposes an organization plan, and safely moves or renames files after you review and approve the changes.
No cloud AI APIs. No uploading private documents. No letting an AI loose on your filesystem without supervision.
Just you, your files, and a local AI model doing the tedious work.
What I Built
Sloth Organizer turns folder chaos into an organized workspace, with AI doing the planning and you staying in control.
We all have that one folder: Downloads, Desktop, Documents, or perhaps an entire drive where files accumulate because organizing them feels like a chore.
Sloth Organizer helps tackle that problem.
Here's how it works:
- Scan: Point the application at a folder. It scans files, calculates hashes, detects file types, and groups potential duplicates.
- Organize: A locally running AI model analyzes the available file information and proposes sensible destinations and optional new filenames.
- Prioritize: Review the generated tasks, grouped by priority so you can focus on what matters.
- Review: Approve or reject each proposed file change individually.
- Apply: Confirm the final summary and let Sloth Organizer execute the approved moves and renames.
The application also supports content previews for formats such as TXT, PDF, DOCX, and XLSX, helping the AI make more informed organization suggestions.
The important distinction? The AI proposes; you decide.
Files are never deleted, and the application includes safeguards against path traversal, unexpected overwrites, and invalid AI-generated responses.
The goal is simple: spend less time managing files and more time doing something you actually enjoy.
Demo
🖥️ Source repository: https://github.com/aimanfazal/sloth-organizer
Sloth Organizer runs locally in your browser, with the application served from your own machine.
To try it, install the prerequisites, set up LM Studio with a compatible chat model, build the frontend, and launch the application. The interface is available at http://localhost:8000.
I haven't included a separate hosted demo or video because the project is designed to run locally. A screen recording showing a messy folder, the generated organization plan, the review screen, and the final result would be a great way to demonstrate the complete workflow.
Code
🐙 GitHub repository: https://github.com/aimanfazal/sloth-organizer
The project is open source under the MIT license.
The main components include:
- Backend: Python, FastAPI, SQLModel, and SQLite.
- Frontend: React and Vite.
- AI integration: LM Studio using its OpenAI-compatible local API.
- File processing: Recursive scanning, SHA-256 hashing, MIME-type detection, and supported document-content extraction.
- Execution safety: Validated AI output, restricted file paths, collision handling, and explicit user approval before changes are applied.
The codebase separates scanning, AI planning, review, and filesystem execution into distinct components, making the workflow easier to understand and maintain.
Check out the repository for installation instructions, configuration options, and implementation details.
How I Built It
I built Sloth Organizer around a simple principle: AI should take care of repetitive decisions without taking away the user's control.
The application combines a Python backend with a React frontend. FastAPI exposes the APIs used by the interface, while SQLite stores application data. WebSockets help communicate scan progress to the frontend.
For the AI layer, Sloth Organizer connects to a model running locally through LM Studio. The model receives file information and relevant content previews, then generates a structured organization plan containing proposed destinations and optional renames.
The backend validates and normalizes the model's response before it can become an executable task. This matters because AI-generated output should never be trusted blindly when it can change someone's filesystem.
The workflow deliberately separates planning from execution:
- Scanning gathers information about the folder.
- AI generates proposed changes.
- The user reviews and approves individual tasks.
- The execution layer checks the approved operations and applies them safely.
That final separation is important. A useful file organizer should not just be intelligent; it should also be predictable and cautious.
The Tech Stack
| Component | Technology |
|---|---|
| Backend API | Python + FastAPI |
| Frontend | React + Vite |
| Database | SQLite + SQLModel |
| AI inference | LM Studio + locally running open-weight model |
| File analysis | SHA-256, MIME detection, document extraction |
| Communication | REST APIs + WebSockets |
The application requires Python 3.11+, Node.js 18+, and LM Studio with a compatible chat model loaded and its local server running.
Why Does Open Innovation Matter?
For this project, open innovation isn't just about using a different AI model. It's about changing where AI runs, who controls the data, and how much freedom developers have to adapt the system.
1. Your files stay yours
Folders often contain sensitive information: personal documents, financial records, work files, and private notes.
By running inference locally through LM Studio, Sloth Organizer does not need to upload file contents to a hosted AI API. The application can perform its core AI workflow without a cloud inference provider, an AI account, or per-request cloud API charges.
Local inference does require suitable hardware and a compatible model, so the actual cost and speed depend on your setup.
2. You choose the model
The application uses LM Studio's OpenAI-compatible API rather than tying the workflow to a single proprietary cloud provider.
You can configure which locally loaded model is used and experiment with different compatible models as your needs change. This provides room to explore trade-offs between speed, quality, hardware requirements, and resource consumption.
3. You can inspect and adapt the software
The MIT-licensed codebase can be examined, modified, and extended. Developers can improve the organization prompts, add document extractors, adjust the safety checks, or build new features around the existing workflow.
4. No unnecessary dependence on a hosted AI service
Once the compatible model is available locally and the application is configured, its AI workflow can run without an external inference API.
That means fewer external dependencies, more predictable control over your data, and the possibility of avoiding recurring inference fees.
For me, that's the real promise of open innovation: making useful AI something people can run, understand, and adapt on their own terms.
My Agent Session
The code and its organization workflow are available in the GitHub repository.
I haven't included a DevRelay agent-session link in this submission. If you capture a session while developing the project, this section is a good place to embed it so readers can follow the implementation process and see how the application took shape.
The Lazy Payoff 🦥
Here's the kind of work Sloth Organizer is designed to eliminate:
- Opening files one at a time to figure out what they are.
- Repeatedly creating folders and moving documents by hand.
- Renaming files to make their purpose easier to recognize.
- Reorganizing a cluttered Downloads folder every few weeks.
- Repeating the same tedious cleanup process whenever files pile up again.
Instead of manually handling every file, you can scan a folder, review the suggested plan, and approve the changes that make sense.
The payoff isn't just fewer clicks. It's lowering the mental friction that makes file organization so easy to postpone.
I don't have a measured time-savings figure to report yet, so I won't invent one. The actual benefit will depend on the number of files, the model's inference speed, and how much manual cleanup the folder would otherwise require.
But the idea is to turn a task people avoid into a workflow that requires much less effort and still leaves the final decisions in their hands.
Slow and steady wins the tidy folder.
Prize Categories
This project is intended for the main Hacktoberfest Open-Source AI Challenge: Week 3 — Slow and Steady.
I'm not claiming a partner category at this stage because the repository's use of LM Studio alone doesn't establish eligibility for any listed partner prize category. If the project uses a qualifying partner's technology and meets that category's requirements, the corresponding entry can be added here.
Final Thoughts
AI is often presented as something that needs to be bigger, faster, and more autonomous.
Sloth Organizer explores a quieter approach: let AI handle the repetitive planning, keep the processing local, and make the human approval step part of the design.
Not every AI agent needs to take over your day. Sometimes the most useful one is the one that quietly tidies up after you.
Build slowly. Organize smartly. Stay lazy. 🦥
Built for Hacktoberfest 2026 — Open-Source AI Challenge, Week 3: Slow and Steady.
Top comments (0)