I Built an Offline AI That Organizes My Downloads So I 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.

We've all been there. You download an assignment, a certificate, a PDF, a screenshot, or an invoice, thinking you'll organize it later.

Before you know it, your Downloads folder is filled with files named document(3).pdf, final_final_v2.docx, and IMG_20261023.png. Finding something important becomes a task of its own.

For this week's Slow and Steady challenge, I wanted to build something that rewards doing absolutely nothing.

So I built HushFile, a fully offline, open-source AI file organizer that quietly handles your digital clutter in the background.

The idea is simple: Drop it in Downloads, forget it, find it later.

HushFile is an autonomous desktop background agent that watches your Downloads folder, understands incoming files using locally running AI models, gives them meaningful names, and moves them into appropriate folders.

Unlike traditional file organizers that depend mainly on extensions or manually configured rules, HushFile analyzes the contents of supported files to determine what they actually contain.

For example, a randomly named PDF containing an educational certificate can be recognized and organized under Education instead of being treated as just another PDF.

And because AI isn't always right, HushFile is designed with safety mechanisms that let users review and reverse its decisions.

HushFile monitors the Downloads folder using a background watcher. When a new file arrives, it waits until the download is complete before processing it.

It then extracts relevant content, determines the document type, generates a descriptive filename, and moves the file into its appropriate category.

HushFile isn't limited to text documents. Its extraction pipeline supports:

Different extraction tools handle different formats, while local AI models interpret the extracted information.

Allowing an AI to move personal files automatically introduces a serious concern: what happens when it makes a mistake?

HushFile maintains a SQLite-based undo journal that records file operations. Users can reverse individual moves or entire batches.

It also checks file hashes before restoration and avoids overwriting an existing file when restoring to an occupied location.

The goal is to make automation convenient without making it careless.

4. Search files by meaning, not just filename

Sometimes we remember what a document contains but not what it was called.

HushFile uses local text embeddings and a vector database to support semantic search.

Instead of remembering an exact filename, I can search for something like:

The system can retrieve relevant indexed files using their content and metadata.

HushFile provides a Quick-Info feature that explains how a file was understood and organized.

It can show the detected document type, summary, relevant facts, tags, category, and classification details.

This helps make the AI's decisions more understandable instead of leaving users wondering why a file ended up in a particular folder.

Rather than manually checking every folder, users can review what HushFile processed, including organized files, duplicates, items requiring review, and failures.

It's a small feature, but it captures the idea behind this week's theme: let the software do the routine work, and check the results when you want to.

HushFile is designed to run locally on a desktop or laptop, so there is no hosted cloud demo.

A typical demonstration includes downloading a document, letting HushFile detect and organize it, reviewing the explanation behind the decision, searching for it using natural language, and undoing the move.

The CLI also supports a dry-run mode, allowing users to preview proposed changes without modifying files.

hushfile doctor hushfile scan --dry-run hushfile start hushfile recent hushfile find "cloud server invoice" hushfile undo hushfile ui Enter fullscreen mode Exit fullscreen mode The full setup instructions are available in the GitHub repository.

The complete project is publicly available on GitHub.

Repository: https://github.com/AntKss07/HushFile HushFile is released under the MIT License and includes its source code, configuration, tests, benchmark tooling, and installation instructions.

It is built primarily with Python and is designed for local execution on Windows, Linux, and macOS.

Anyone interested in local AI, privacy-conscious automation, or file management can explore the implementation and adapt it to their needs.

I built HushFile around one important decision:

The open-weight AI model should run on the user's own computer, not behind an external inference API.

When a new file enters the monitored folder, HushFile follows a structured workflow:

Detect → Stabilize → Fingerprint → Extract → Understand → Decide → Organize → Index

First, the folder watcher detects a new file and checks that it has finished downloading.

Next, SHA-256 fingerprinting helps identify duplicate content.

Depending on the file format, HushFile extracts text, performs OCR, or uses audio transcription or vision processing.

The extracted information is then passed to a local language model, which generates a structured result containing the proposed category, filename, summary, and metadata.

Pydantic validates the model output before the decision engine uses it.

If the model output is invalid, the pipeline includes a retry and a deterministic fallback. Low-confidence results can be routed to a review folder rather than being blindly organized.

Finally, the move is recorded in the undo journal, and file information is indexed for subsequent searches.

Another challenge was making the pipeline practical on consumer hardware.

The project targets laptops with approximately 8 GB of GPU VRAM rather than requiring an expensive dedicated AI server.

Running several language, vision, and audio models simultaneously can exhaust available memory.

To address that, HushFile uses a sequential processing queue and Ollama model lifecycle controls so that large models don't need to remain loaded simultaneously.

The trade-off is throughput: files are handled sequentially, so large batches can take time.

But for an assistant that quietly processes downloads in the background, predictable memory consumption matters more than processing everything at once.

Autonomous file operations need more than a good classification model.

The goal wasn't simply to make an AI that organizes files. It was to make one whose actions could be inspected and reversed.

I also wanted to evaluate the models rather than assume that a larger model would automatically be better.

The repository includes benchmark tooling for comparing category accuracy, average processing time, review routing, and peak GPU memory use.

The README reports the following results on its labeled test set:

These are project-specific results, not claims of general document-classification accuracy.

The comparison shows an important trade-off: the local language model provides more capable classification on this dataset, while the rule-based fallback processes files much faster with minimal hardware requirements.

This also highlights why the review queue matters. An autonomous organizer should have a way to handle uncertain cases instead of forcing every file into a possibly incorrect category.

For HushFile, open innovation isn't just about making the source code public.

It's what makes the entire approach practical.

Our Downloads folders can contain some of our most sensitive information: identity documents, certificates, invoices, financial statements, and personal records.

With a cloud-based AI workflow, file contents may need to be transmitted to a third-party service for processing.

HushFile instead uses local inference. After the necessary software and models have been downloaded, its core AI processing can operate without an internet connection.

The application does not require users to upload personal files to an external model API.

A cloud-based AI workflow can introduce usage-based inference costs.

With HushFile, the model runs locally. Processing additional documents doesn't generate per-file charges from an external inference provider.

Of course, local inference still consumes electricity, disk space, CPU/GPU resources, and time. It isn't literally free.

But users gain much more control over their operating costs.

The project isn't permanently tied to one model provider.

Ollama makes it possible to experiment with different compatible open-weight models, allowing users to evaluate trade-offs between speed, memory usage, and classification quality.

That matters for hardware accessibility. A configuration suitable for a gaming laptop might not be ideal for a smaller CPU-only machine.

Developers can inspect the pipeline, change classification categories, modify naming conventions, evaluate model performance, or extend supported file formats.

The underlying behavior is not hidden behind an inaccessible service.

Running models locally introduces installation complexity, hardware constraints, and slower inference on less powerful machines.

An AI classifier can still misunderstand documents or produce inaccurate metadata, even when its output follows a valid schema.

That's why HushFile combines AI interpretation with conventional software safeguards, fallback rules, human review, and undo functionality.

For this project, the biggest benefit of open innovation is control: control over where data goes, which models run, how files are handled, and how mistakes are corrected.

The best part of HushFile is that its intended daily workflow barely involves the user.

Instead of repeatedly opening Downloads, reading filenames, creating folders, renaming files, and deciding where everything belongs, I can delegate those repetitive steps to a local background process.

And when I need something later, semantic search reduces my dependence on remembering exact filenames.

I don't have a verified daily time-savings figure yet, so I won't claim HushFile saves a specific number of minutes per day.

What I can measure is the work the software is designed to replace: repetitive classification, naming, moving, and searching.

The current model benchmark also makes an important point: local AI processing isn't necessarily instantaneous. In the reported run, Qwen3 4B averaged 45.2 seconds per file.

But the philosophy of Slow and Steady isn't that every operation must be fast.

It's that the computer can handle the boring work at its own pace while I focus on something more useful.

And that is exactly what I wanted HushFile to do.

This project taught me that useful AI automation isn't only about making a model perform a task.

It's also about making the surrounding system reliable, explainable, private, and recoverable when things go wrong.

HushFile isn't the first AI-powered file organizer, and there are already open-source projects exploring local document classification and file organization.

My focus was on combining that capability with a crash-safe undo journal, explainable file information, semantic retrieval, and reproducible local-model benchmarks.

There's still room to improve, particularly in learning from user corrections, expanding the evaluation dataset, and supporting more languages.

Not every AI assistant needs to live in the cloud, and not every useful automation needs constant supervision.

Sometimes, the most useful assistant is the one that quietly handles the boring work and lets you get on with your day.

Drop it in Downloads. Forget it. Find it later.

GitHub: https://github.com/AntKss07/HushFile