I Built SlothSort: A Local AI Agent That Organizes Your Digital Mess So You Don't Have To

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

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

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 download a PDF for college. A screenshot for a project. A random ZIP file. A few invoices. Some lecture notes.

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.

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.

Drop files into a folder. Let AI figure out the boring part.

The workflow is designed around five capabilities:

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.

Downloads/ ├── IMG_20261020_142312.png ├── document(7).pdf ├── assignment_final_final.pdf ├── invoice_oct.pdf ├── react-project.zip └── DBMS_unit3_notes.pdf Enter fullscreen mode Exit fullscreen mode 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 Enter fullscreen mode Exit fullscreen mode No manually creating folders. No individually renaming documents. No dragging files around.

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.

🚧 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.

I'll update this section with a walkthrough showing the complete flow:

The repository will include the application source code, setup instructions, model configuration, and an example dataset for testing the organization workflow.

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.

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 Enter fullscreen mode Exit fullscreen mode 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.

{ "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." } Enter fullscreen mode Exit fullscreen mode This example illustrates the intended output format, not a measured model result.

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.

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.

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:

The ideal experience is one where the user gradually stops thinking about file organization.

But because the repetitive maintenance is handled.

This project would be fundamentally different if it depended entirely on a closed AI API.

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.

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.

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.

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.

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.

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.

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.

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.

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.