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

What I Built

LogSloth — Lazy Developer's Error Detective

LogSloth is a local-first AI-powered log-triage tool designed to make debugging less tedious. It helps developers analyze noisy application logs by grouping recurring errors, identifying error spikes, and generating concise diagnostic summaries with suggested debugging steps.

Instead of manually searching through hundreds of repetitive log lines, developers can let LogSloth handle the initial investigation and focus on fixing the actual problems.

Built around the idea of “You relax. We read the logs.”, LogSloth combines deterministic log processing with local AI to make debugging more efficient while keeping sensitive log data on the developer's machine.

Demo

yashr5120 / LogSloth

LogSloth is a local-first AI log-triage tool that groups recurring errors, detects error spikes, and generates actionable debugging insights using open-weight Gemma models via Ollama. Built for privacy-conscious developers.

🦥 LogSloth — Lazy Developer's Error Detective

You relax. We read the logs.

LogSloth is a local-first AI log-triage tool that automatically parses, groups, and explains your application errors — powered by a locally running Gemma model via Ollama.

Built for Hacktoberfest 2026 — Slow and Steady challenge.

---

🚨 The Problem

Application logs are noisy. A single bug can generate thousands of nearly-identical error lines. Finding the signal in that noise is tedious, manual, and slow. Most log tools send your data to the cloud.

✅ The Solution

LogSloth runs entirely on your machine:

1. Reads your log files
2. Parses and normalises entries (including multiline stack traces)
3. Redacts secrets before anything is analysed
4. Groups repeated errors into incidents using deterministic fingerprints
5. Detects error spikes automatically
6. Uses a local Gemma model (via Ollama) to generate evidence-backed summaries
7. Shows everything in a polished Streamlit dashboard
8. Persists incident metadata in SQLite
9. Exports sanitised…

View on GitHub

Code

https://github.com/yashr5120/LogSloth

How I Built It

I built LogSloth using Python, Streamlit, Ollama, and Gemma, with SQLite for incident history.

The application follows a simple pipeline:

Log ingestion: Load application logs and monitor selected log files.

Error grouping: Normalize messages and group recurring errors using deterministic fingerprints.

Detection: Count occurrences, prioritize incidents, and identify unusual increases in error frequency.

Local AI analysis: Use a Gemma model running through Ollama to summarize sanitized log evidence and suggest debugging checks.

Incident dashboard: Present prioritized errors, supporting evidence, and diagnostic reports in a developer-friendly interface.

An important design decision was to let conventional code handle predictable tasks such as parsing, counting, and grouping, while using AI for interpreting error patterns and generating explanations.

Why Does Open Innovation Matter?

Open innovation is central to LogSloth because application logs can contain sensitive information about software systems, infrastructure, and users.

By using an open-weight model locally through Ollama, LogSloth can analyze logs without requiring a hosted AI API. Once the model and dependencies are installed, the core workflow can operate without an internet connection, subject to the local environment and configuration.

The open-weight approach also makes it possible to experiment with different compatible models, customize prompts, inspect the processing pipeline, and adapt the tool to different development workflows.

Instead of relying on a recurring cloud inference service, developers can run their own local diagnostic assistant and retain greater control over their data.

The Lazy Payoff

LogSloth aims to reduce the repetitive work involved in investigating application logs.

Rather than reading the same error message dozens of times, developers can inspect grouped incidents, review a concise explanation, and follow targeted debugging checks.

The intended payoff is less time spent searching through noisy logs and more time spent building and fixing software.

Prize Categories

Best use of Gemma