Sloth Desk

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

What I Built

Sloth Desk: an offline overnight tidier for your laptop that reports to a tiny sloth on your desk.

While you sleep, a local agent powered by an open-weight model goes through the clutter you keep putting off:

• Downloads folder: it reads each file, renames it sensibly (invoice_acme_2026-10.pdf instead of scan0034.pdf) and moves it to the right folder.
• Screenshots: it describes each one with a local vision model, renames it and archives it.
• Duplicates and junk: it finds old installers and duplicate files and puts them in a review folder. Nothing is ever deleted automatically.

In the morning, a sloth on a 2-inch ESP32 touchscreen sits on your desk and shows a two-line summary:

🦥 Sorted 42 files, archived 17 screenshots.
3 things need you: 2 duplicates, 1 unknown PDF.

Tap the screen to approve or undo the batch. The sloth also changes with the result: it's asleep while the agent works, stretches when it's done, and holds up a little sign when something needs your attention.

Status: this is a concept submission. The design and architecture are below; I haven't built it yet.

Demo

This is a concept, so there's no live demo yet. Here's the planned flow:

1. 11 PM: the sloth falls asleep and the local agent starts its slow, low-priority run.
2. Overnight: the agent reads, classifies, renames and moves files, logging every action.
3. 7 AM: the sloth wakes up and shows the two-line summary.
4. One tap: you accept the batch, or undo it from the log.

[Mockup / storyboard image here]

Code

Planned repository layout (not yet built):

sloth-desk/
├── agent/            # Python agent (runs on the laptop)
│   ├── rules.yaml    # user rules: folders, naming patterns, never-touch paths
│   ├── tidy.py       # scan → classify → propose → act → log
│   └── undo.py       # roll back any night's batch from the action log
└── firmware/         # ESP32-S3 + LVGL sloth display
    └── sloth.cpp     # sprite states + 2-line summary + approve/undo buttons

How I Built It

This is the planned architecture:

1. Local model runtime

• An open-weight model runs through Ollama or llama.cpp on the laptop.
• A small instruct model handles classification and naming. A small open vision model reads screenshots and scanned PDFs.
• It only needs to run once a night, so a quantized model on a CPU is fine. Speed doesn't matter, which suits the slow-and-steady theme.

2. Agent loop (open-source framework)

• The agent is built on an open-source agent framework with a small, fixed set of file tools: list, read_text, describe_image, rename, move, flag_for_review.
• It's prevented from deleting anything. The worst it can do is move a file into a review folder.
• Each action is written to a JSON log before it runs, so undo.py can roll back a whole night's batch.

3. Rules and personalization

• rules.yaml holds folder targets, naming templates and paths the agent must never touch.
• Over time, the files you rename yourself can become examples for a small LoRA fine-tune, so the model learns your naming style.

4. The sloth display

• The ESP32-S3 touchscreen gets the summary over local Wi-Fi as a small JSON message from the laptop. Nothing goes to the internet.
• Built with LVGL: sprite states (sleeping, stretching, holding a sign), the two-line summary, and Approve/Undo buttons.
• The screen only redraws when the sloth's state changes, so the display sleeps nearly all day.

Why Does Open Innovation Matter?

• My files never leave my machine. The agent reads bank statements, IDs, invoices and screenshots of private chats. A closed, cloud-based model would mean uploading all of that to someone else's server. With an open-weight model running locally, the data stays on my disk.
• It works with no internet. The nightly run doesn't depend on an API key, a rate limit or a service being up.
• It costs nothing to run. Thousands of files a night would get expensive with a paid API. Locally, it's just a little electricity while I sleep.
• I can swap models. If a better small open model comes out, I change one line in the config. I'm not locked to one provider's model or pricing.
• I can fine-tune it to my habits. Open weights let me train the model on my own naming style, which a closed API wouldn't let me do on my own hardware.
• The agent is auditable. With an open-source agent framework, I can read exactly what the agent can do and limit it. In this case, it can't delete anything.

My Agent Session

This is a concept, so there's no agent session yet. The first session would follow this plan:

1. Set up Ollama with a small instruct model and a small vision model.
2. Have the agent do a dry run: propose names and folders for 50 sample files without moving anything.
3. Compare its proposals with how I'd name the files, then refine rules.yaml.
4. Turn on real moves with the action log and test undo.py.
5. Connect the ESP32 display and send it the first morning summary.

[Screenshots / logs to be added once built]

The Lazy Payoff

• No more tidying: the clutter I keep putting off gets handled while I sleep.
• One tap a day: my whole job is glancing at the sloth and tapping Approve.
• No risk: nothing is deleted, and everything can be undone.
• No cost and no cloud: I set it up once, run it forever, and my files stay private.
• Sloth energy: the agent works slowly through the night at low priority, and that's fine. 🦥

Prize Categories

[Select the prize categories you're entering]