I Built SlothSort: A Local AI Agent That Organizes Your Digital Mess So You Don't Have To
This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.
What I Built
My Downloads folder has been a mess for years. I finally decided to make that someone else's problem. Except that someone is an AI agent running on my own computer.
You know the routine.
You download a PDF for college. A screenshot for a project. A random ZIP file. A few invoices. Some lecture notes.
Everything ends up in Downloads.
A week later, you're looking for document_final_v2_REAL_final.pdf, and suddenly you're spending 20 minutes searching through files you don't even remember downloading.
Organizing everything manually isn't particularly difficult. It's just repetitive, boring, and easy to postpone.
And that's exactly the kind of work I wanted to automate.
Introducing SlothSort 🦥
SlothSort is a local-first AI file organization agent designed to quietly clean up digital clutter while you focus on more important things.
Instead of asking you to manually rename, categorize, and move every file, SlothSort uses an open-weight language model to understand what a file contains and suggest where it belongs.
The idea is simple:
Drop files into a folder. Let AI figure out the boring part.
The workflow is designed around five capabilities:
- Understand files: Read filenames, supported document contents, and metadata to determine what a file is actually about.
- Automatically categorize: Group files into meaningful categories such as college notes, invoices, projects, screenshots, and personal documents.
-
Suggest better filenames: Turn names like
scan_00482.pdfinto something descriptive, such asDatabase_Management_Notes.pdf. - Detect possible duplicates: Identify repeated downloads and avoid unnecessary clutter.
- Organize safely: Preview proposed changes before moving or renaming anything, with an undo mechanism for completed operations.
The goal isn't to create another chatbot that tells you how to organize your files.
It's to create a tool that actually handles the organization.
A Real-World Example
Imagine downloading these files:
Downloads/
├── IMG_20261020_142312.png
├── document(7).pdf
├── assignment_final_final.pdf
├── invoice_oct.pdf
├── react-project.zip
└── DBMS_unit3_notes.pdf
After analysis, SlothSort could propose:
Organized/
├── College/
│ ├── Assignments/
│ │ └── Assignment.pdf
│ └── Notes/
│ └── DBMS_Unit_3.pdf
├── Finance/
│ └── Invoices/
│ └── October_Invoice.pdf
├── Development/
│ └── React/
│ └── react-project.zip
└── Images/
└── IMG_20261020_142312.png
No manually creating folders. No individually renaming documents. No dragging files around.
Just a reviewable organization plan.
And if the model isn't confident about a file, it should leave that file alone rather than guessing.
That's an important design decision: automation should reduce work, not create new problems.
Demo
🚧 Deployment and public demo are being prepared.
SlothSort is being developed as a local-first application, so the intended experience doesn't require uploading personal documents to a hosted AI service.
Demo: Coming soon
I'll update this section with a walkthrough showing the complete flow:
- Selecting a messy folder
- Running local AI analysis
- Previewing suggested categories and filenames
- Approving the organization plan
- Reviewing the resulting folder structure
Code
GitHub repository: Coming soon
The repository will include the application source code, setup instructions, model configuration, and an example dataset for testing the organization workflow.
How I Built It
The most important architectural decision was to keep the AI inference local.
For a file organizer, sending personal documents to a remote server just to decide which folder they belong in feels unnecessary.
So I designed SlothSort around an open-weight model and a lightweight local processing pipeline.
The Planned Tech Stack
| Component | Technology |
|---|---|
| AI model | Gemma 3 (open-weight) |
| Local inference | Ollama |
| Backend | Python |
| API layer | FastAPI |
| Frontend | React + Tailwind CSS |
| File processing | Python standard library and document parsers |
| Local storage | SQLite |
| Background processing | Local filesystem watcher |
How the Pipeline Works
User selects a folder
|
v
File discovery
|
v
Metadata + text extraction
|
v
Local Gemma inference
|
v
Structured JSON output
|
v
Validate proposed changes
|
v
Preview organization
|
User approval
|
v
Execute file operations
|
v
Save undo history
1. Understanding File Contents
The first challenge is that filenames are often useless.
A file named notes.pdf could be a college assignment, meeting notes, or an instruction manual.
So the processing layer extracts useful information from supported files before passing a compact representation to the model.
The model receives a prompt containing the filename, file type, extracted text, and available categories.
It then returns a structured classification.
For example:
{
"original_name": "document_7.pdf",
"category": "College",
"subcategory": "Notes",
"suggested_name": "DBMS_Normalization_Notes.pdf",
"confidence": 0.94,
"reason": "Document discusses database normalization and relational schemas."
}
This example illustrates the intended output format, not a measured model result.
2. Keeping AI Away From Destructive Operations
One thing I didn't want was an AI model having unrestricted access to my filesystem.
A model should be able to recommend actions, but it shouldn't be trusted to execute arbitrary file operations.
So SlothSort separates reasoning from execution.
The model generates a proposed plan.
The application validates that plan.
Only the deterministic file-management layer can perform the approved operations.
That means checking destination paths, handling filename collisions, preventing traversal outside allowed folders, and recording changes.
The AI decides what makes sense. Regular code decides what is safe.
3. Designing for Slow and Steady Automation
This is where the Hacktoberfest theme becomes especially relevant.
SlothSort isn't meant to be an AI assistant that constantly demands attention.
The long-term workflow is designed to be:
- Incremental: Process new or changed files instead of rescanning everything.
- Quiet: Avoid unnecessary notifications and interruptions.
- Resource-aware: Use background processing rather than competing with active tasks.
- Recoverable: Maintain an operation history so file movements can be reversed.
- Conservative: Leave ambiguous files untouched until the user reviews them.
The ideal experience is one where the user gradually stops thinking about file organization.
Not because the files have disappeared.
But because the repetitive maintenance is handled.
Why Does Open Innovation Matter?
This project would be fundamentally different if it depended entirely on a closed AI API.
1. Your files should remain yours
A file organizer potentially handles sensitive documents.
College records. Invoices. Contracts. Personal notes.
With a local open-weight model, document text can be processed on the user's machine instead of being sent to an external model provider.
That doesn't automatically guarantee security, but it removes an unnecessary external data transfer from the core workflow.
2. No per-file API billing
A folder might contain 20 files or 20,000.
With a paid API, repeated classification can introduce ongoing usage costs.
A locally hosted model avoids per-request inference fees, although it still consumes the user's computing resources and electricity.
For a background utility, predictable operating costs matter.
3. The model isn't permanently fixed
Using an open-weight model makes it possible to experiment with different model sizes, quantization levels, prompts, and eventually task-specific fine-tuning.
A smaller model might be sufficient for simple document categorization.
A more capable model could handle ambiguous files.
That flexibility is valuable because a utility like SlothSort needs to balance accuracy, memory usage, and processing speed.
4. Offline operation becomes possible
Once the required software and model weights are installed, the core file-classification workflow can run without an internet connection.
That's particularly useful for a desktop utility that should continue working regardless of network availability.
5. The community can improve the rules
Open innovation isn't just about model weights.
It's also about making the automation inspectable and customizable.
Different users organize files differently.
A developer might want folders grouped by programming language. A student might prefer semester and subject. A freelancer might want client and project.
A transparent rules engine combined with a configurable model gives people control over how their own files are organized.
The Lazy Payoff
I wanted to define what success would actually look like.
Not in terms of how impressive the AI sounds, but in terms of how much repetitive work it eliminates.
Consider a hypothetical batch of 100 files.
If manually inspecting, renaming, and moving each file takes an average of 30 seconds, that's:
100 files × 30 seconds = 50 minutes of manual work.
If an automated workflow could reduce the task to five minutes of reviewing suggestions, that would represent 45 minutes saved.
That's a potential 90% reduction in hands-on time.
These numbers are illustrative, not benchmark results. Actual performance will depend on model speed, file types, classification accuracy, and how many suggestions need correction.
For me, the more interesting payoff isn't even the number of minutes saved.
It's eliminating one more repetitive task from everyday life.
Because organizing files isn't something I want to become better at.
It's something I want to spend less time doing.
What's Next?
There are several directions I want to explore as SlothSort develops.
Semantic search: Instead of remembering filenames, users could search for things like "the database notes I downloaded last week."
Custom organization rules: Let users describe how they want their folders structured in natural language.
Smarter duplicate detection: Identify identical files using hashes and eventually detect documents with highly similar contents.
Learning from corrections: Use user-approved changes to improve future suggestions without silently retraining or changing behavior.
Background automation: Watch selected folders and prepare organization suggestions as new files arrive.
The goal is to make SlothSort useful without making it complicated.
Final Thoughts
We spend a surprising amount of time doing tiny repetitive tasks on our computers.
Renaming files. Creating folders. Sorting documents. Searching for downloads.
None of these tasks is particularly difficult.
But they add up.
The interesting thing about open-source AI is that it gives us the freedom to build small, personal tools that solve these problems without necessarily depending on an expensive hosted service.
Not every AI project needs to be a massive autonomous agent.
Sometimes, a useful AI application is simply one that quietly takes a boring task off your plate.
SlothSort is my attempt at making digital organization one less thing to worry about.
And that feels pretty aligned with the spirit of Slow and Steady. 🦥
Built for Hacktoberfest 2026 — Open-Source AI Challenge, Week 3: Slow and Steady.
Top comments (0)