🦥 SlothTab: Let Local AI Handle the Boring Stuff

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

I built SlothTab, a local-first AI assistant for people who keep saying:

"I'll organize it later."

We all have that one folder.

Downloads full of:

IMG_8273.png`` final_final2.pdf``document123.pdf SlothTab lets you drop those files into an inbox and lets local AI figure out what to do with them.

It can:

Instead of spending 15 minutes organizing a folder manually, I can drop everything into SlothTab and let the sloth do the work.

The goal is simple:

Do less. Let AI handle the boring parts.

For example:

Before

Downloads/
├── IMG_8273.png
├── final_final2.pdf
├── cloudnotes.txt
├── receipt.jpg
├── document123.pdf
└── screenshot.png

After SlothTab:

College/
├── Cloud Computing/
│   └── cloud-computing-lab.pdf
│
└── Notes/
    └── cloud-computing-notes.txt

Screenshots/
└── cloud-console-screenshot.png

Receipts/
└── receipt.jpg

And hopefully the user is nowhere near the keyboard. 🦥

https://github.com/neomon-dev/SlothTab.git

SlothTab is designed to be open and extensible, particularly around the AI layer.

The AI provider is abstracted so the application isn't tied to one model or one company.

You can use a local model through:

That means the model powering SlothTab can be changed without rebuilding the entire application.

SlothTab is built around a local-first AI architecture.

The basic flow looks like this:

                 🦥 SlothTab
                      │
                      ▼
                Local files
                      │
                      ▼
             File text / image
                 extraction
                      │
                      ▼
              Local AI model
                      │
                      ▼
            Structured JSON
                      │
                      ▼
              Safety validation
                      │
                      ▼
          User approval / Auto Mode
                      │
                      ▼
             File organization

The frontend is built with React + TypeScript, while the backend uses Python + FastAPI.

SQLite is used for local persistence, including activity history and reversible file operations.

For document processing, SlothTab extracts information locally before sending the relevant content to the configured local model.

The AI doesn't directly control the filesystem.

Instead, it produces a structured recommendation such as:

{
  "category": "College",
  "subcategory": "Cloud Computing",
  "suggested_filename": "cloud-computing-lab.pdf",
  "suggested_destination": "College/Cloud Computing",
  "summary": "Instructions for a cloud computing lab.",
  "importance": "medium",
  "confidence": 0.94
}

The application validates that response before performing any operation.

This separation is important:

AI → Recommendation
       ↓
Validation
       ↓
Application
       ↓
File operation

rather than giving the AI direct access to shell commands or filesystem operations.

This is probably the most important part of SlothTab.

A traditional cloud AI implementation could send my documents to a remote API every time I wanted to organize them.

For a tool dealing with personal documents, screenshots, assignments, receipts, and potentially sensitive information, I didn't want that to be the default.

With local/open-weight AI, SlothTab can instead work like this:

My files
   ↓
My laptop
   ↓
My local model
   ↓
My organized files

The files don't need to leave my machine.

SlothTab is designed so that document processing can happen locally.

That's particularly useful for files that I wouldn't want to upload to an external AI service.

Once the application and model are installed, the core AI workflow can work without an internet connection.

The assistant doesn't need to call a cloud model just to decide where a PDF belongs.

I'm not locked into one AI provider.

I can experiment with different open-weight models and choose the one that works best for my hardware and workload.

Because the model and prompts are under my control, I can change how SlothTab behaves.

Want different categories?

Change the configuration.

Want stricter confidence thresholds?

Change them.

Want a different model?

Swap it.

Want to modify the AI's reasoning workflow?

The code is there.

There is no requirement to pay a cloud API every time SlothTab processes another document.

The main computational cost is instead running the model locally.

That changes the economics of building small AI automations.

The entire point of SlothTab is to remove the tiny tasks that aren't difficult—but are annoying enough that we keep postponing them.

Instead of:

Find file
    ↓
Open file
    ↓
Understand file
    ↓
Choose folder
    ↓
Rename file
    ↓
Move file
    ↓
Repeat × 20

SlothTab turns it into:

Drop files
    ↓
🦥
    ↓
Review
    ↓
Done

The most satisfying metric isn't how fast the AI responds.

It's how little I have to do.

And that's what I wanted from this challenge:

an AI that rewards laziness rather than demanding more work from me.

Open AI isn't interesting to me simply because it's "free" or because I can run a model locally.

It's interesting because it gives developers a different set of possibilities.

With SlothTab, the AI can become part of the user's computer rather than another website the user has to send their data to.

The model can be swapped.

The prompts can be changed.

The application can work offline.

The entire pipeline can be inspected and modified.

And most importantly...

I don't have to organize my Downloads folder anymore.

The sloth has it covered. 🦥

source & further reading

dev.to — original article One Browser per Country: Running Several VPN Locations Simultaneously How I keep a living system map of Mầm Văn — every change, before & after Fork, Fix, Delete: Safe Database Migrations with GitHub Copilot and Tiger Cloud