LazyDesk: A Local AI File Organizer That Cleans Up Your Digital Mess
This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
What I Built
LazyDesk is a privacy-first AI file organizer that does the boring work of cleaning up your computer for you.
My Downloads folder often becomes a mess of PDFs, screenshots, documents, images, ZIP files, code files, and random files with confusing names. Organizing everything manually takes time, and I keep postponing it because it feels like a chore.
LazyDesk is designed to solve this problem with a small, locally running AI model.
Instead of manually opening every file and deciding where it belongs, LazyDesk can:
- Automatically categorize files into folders such as Documents, Images, Code, Projects, and Archives.
- Suggest meaningful filenames based on file contents when supported.
- Identify potential duplicates and help prevent unnecessary clutter.
- Generate a simple summary of what is inside a messy folder.
- Create a cleanup plan showing which files should be moved, renamed, or reviewed.
- Ask for confirmation before making changes, so the user stays in control.
The goal is simple: spend less time managing files and more time doing the work that actually matters.
No complicated setup of cloud AI services is required for the core AI workflow. LazyDesk is designed to run locally using an open-weight model, keeping personal documents on the user's own machine.
Demo
The demo will show LazyDesk taking an unorganized Downloads folder and turning it into a clean, structured workspace.
The workflow:
- Select a folder to organize.
- Let the local AI analyze supported files and suggest categories.
- Preview the proposed changes.
- Approve the cleanup plan.
- Watch LazyDesk organize the files and generate a summary.
The demo will include a before-and-after comparison to demonstrate the result.
Code
Project: LazyDesk
Planned technology stack:
- Python for file handling and automation.
- Ollama for running an open-weight language model locally.
- Qwen2.5 3B as the initial model for classification and filename suggestions.
- A lightweight interface for selecting folders, reviewing suggestions, and approving actions.
- Standard Python libraries for filesystem operations and duplicate detection.
The project will be organized into separate modules for AI-based classification, file scanning, cleanup planning, safe file operations, and reporting.
All file operations will use a preview-first workflow. The application will avoid deleting files automatically and will keep a record of completed changes so users can review what happened.
How I Built It
LazyDesk is designed around the idea that AI should handle repetitive decisions without taking control away from the user.
The workflow begins with a Python file scanner that collects basic metadata, such as filenames, extensions, file sizes, and folder locations. Where supported, the application can extract limited text from documents to improve classification.
The local language model then suggests a category, a clearer filename, and a reason for each recommendation. Python validates the suggestions and prepares a cleanup plan.
Before anything changes on disk, the user can inspect the plan and approve or reject individual actions.
The key components are:
- Local inference: Ollama runs the selected open-weight model.
- AI reasoning: The model suggests file categories and descriptive names.
- Automation: Python handles folder creation, file movement, and reporting.
- Safety: Preview mode, user approval, collision checks, and error handling help prevent accidental changes.
The initial implementation will focus on common file types and a manageable folder size. More advanced document understanding and additional models can be introduced later.
Why Does Open Innovation Matter?
For a tool that reads and organizes personal files, privacy should not be an afterthought.
A cloud-based AI service could perform similar classification, but it might require uploading filenames, document contents, or other sensitive information to an external provider.
LazyDesk takes a different approach: the AI can run locally, allowing file analysis to happen on the user's own computer.
Open-weight models also make experimentation possible. Developers can compare different models, adjust prompts, change the classification rules, and improve the workflow without tying the project to a single proprietary AI API.
Open innovation makes this project more accessible because developers can inspect the implementation, adapt it to their needs, and contribute improvements to the community.
The goal isn't to prove that local AI is always better than cloud AI. It is to show that a small, focused model can be useful for everyday automation while offering greater control over data, model selection, and running costs.
My Agent Session
The initial version will focus on building and testing the local file-organization workflow.
An agent session or development walkthrough can be added after implementation and testing. It will demonstrate how the model makes recommendations, how the cleanup plan is validated, and how the application handles errors or conflicting filenames.
The Lazy Payoff
The real win is eliminating a task that people repeatedly postpone.
For an initial experiment, I plan to test LazyDesk on a folder containing approximately 100 mixed files and compare the time needed for manual organization against the time needed to review and approve the AI-generated cleanup plan.
The goal is to reduce repetitive sorting and renaming while keeping the user in control.
The application will also measure how long local inference takes, how many suggestions are accepted, and how many files require manual review.
Rather than claiming a time-saving figure without evidence, I'll use these measurements to understand where the tool genuinely helps.
My definition of lazy productivity: automate the boring parts, review the important decisions, and get back to work.
Prize Categories
- Open-source AI and local inference.
Top comments (0)