Inspiration

Developers spend a surprising amount of time on repetitive work: organizing files, reviewing notes, finding duplicate documents, extracting action items, and checking datasets. I wanted to build something that could handle this busywork while keeping the user in control.

That idea led to SlothDesk AI — a productivity assistant inspired by the philosophy of working smarter, not harder. Like a sloth, it encourages a slower, more deliberate approach to automation: analyze first, review the proposed changes, and execute only when approved.

What it does

SlothDesk AI helps users analyze documents, extract tasks and decisions, identify duplicate files using SHA-256 hashing, organize workspace files through reviewable proposals, and profile CSV datasets.

Its key features include:

AI-assisted document analysis using Gemma 3 through Ollama when local inference is available.
Deterministic fallback analysis when the AI model is unavailable.
Dry-run previews and explicit approval before supported filesystem operations.
Workspace boundary checks, collision-safe file handling, and hash-verified rollback safeguards.
CSV profiling for missing values, duplicate rows, and inferred data types.
Execution history and reports to make automation more transparent.

The application is deployed on Render, with hosted-mode restrictions that prevent the hosted service from operating directly on users' local filesystems.

How we built it

SlothDesk AI is built with TypeScript, Node.js, HTML, and CSS. Its architecture separates document analysis, workflow planning, and filesystem execution so that generated recommendations are not automatically treated as permission to make changes.

For local AI inference, the application integrates Gemma 3 (gemma3:4b) through Ollama. When the model is available, supported workflows can use its structured analysis. If inference is unavailable or fails, the application falls back to deterministic logic and records which provider was used.

We also implemented filesystem safety checks, cryptographic duplicate detection, server-authoritative approvals, and rollback integrity verification. The frontend uses a responsive, tactile neo-brutalist design with a cream, charcoal, and orange palette.

The project builds successfully, and the automated test suite passes 68 out of 68 tests, including tests for provider fallback, malformed model responses, timeouts, and filesystem security.

Challenges we ran into

One of the biggest challenges was balancing useful automation with filesystem safety. An AI-generated suggestion should never be enough to authorize a potentially destructive action, so we separated analysis from execution and added explicit approval gates.

Another challenge was making the AI integration resilient. Local models may be unavailable, take longer to load, or return invalid output. We addressed these cases with bounded timeouts, response validation, sanitized errors, and deterministic fallback behavior.

We also had to account for the difference between local and hosted environments. The hosted Render deployment cannot rely on a developer's local Ollama instance, so it uses restricted hosted mode rather than pretending local AI and filesystem capabilities are available everywhere.

Accomplishments that we're proud of

Built a working productivity application that combines document analysis, duplicate detection, workspace organization, and CSV profiling.
Integrated an Ollama-based Gemma inference path with explicit provider status and fallback handling.
Implemented human approval gates and rollback safeguards instead of allowing unchecked filesystem changes.
Added automated coverage for adversarial filesystem cases, model failures, and report generation.
Achieved a successful TypeScript build and 68 passing automated tests.
Deployed the application to Render while preserving restrictions on hosted filesystem operations.
Created a distinctive, responsive interface that makes automation proposals easier to inspect and understand.

What we learned

We learned that a useful AI agent is not just about generating intelligent responses. It also needs predictable behavior, clear evidence, safe execution boundaries, and an honest way to handle failure.

Open-weight models and local inference offer developers greater control over how supported AI processing runs. At the same time, deterministic algorithms remain the right choice for tasks such as cryptographic duplicate detection and structured CSV profiling, where reproducibility matters.

Most importantly, we learned to treat AI as an assistant that proposes actions—not as an authority that should execute them without user consent.

What's next for SlothDesk AI

The next phase is focused on making SlothDesk AI more capable without compromising its safety-first approach.

Planned improvements include:

Expanding document-analysis workflows and improving extraction quality.
Testing Gemma inference across different local hardware configurations.
Adding more useful automation recipes with transparent previews and approval gates.
Improving execution reports, diagnostics, and workflow observability.
Expanding test coverage and documenting setup for new contributors.
Exploring additional local models and configurable inference options.

The long-term goal is to build a dependable, open-source productivity assistant that takes care of repetitive work while leaving important decisions in the user's hands.