LogSherlock: An AI Log Investigator That Has to Prove Its Claims

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

LogSherlock is an AI-powered log investigator that turns messy application logs into evidence-backed debugging reports.

When an application fails, developers often spend hours searching through thousands of log lines, grouping recurring errors, identifying the root cause, and figuring out what to investigate next. LogSherlock automates much of that work.

I built it for freelance developers, indie hackers, and small engineering teams who need faster debugging without paying for an expensive observability platform.

The key design decision: AI has to show its evidence. If a model produces invalid citations, LogSherlock can attempt a bounded repair and fall back to deterministic findings rather than blindly trusting the answer.

The goal is not to replace developers. It is to help them get from “something broke” to “here is what to investigate” faster.

The business model is still a hypothesis, not validated revenue: a free tier for occasional debugging, a proposed ₹499/month Solo plan, and a proposed ₹1,999/month Team plan.

Live demo: https://log-sherlock.vercel.app/

A useful demo should show the complete flow:

I’m also planning to add a short screen recording so people can see the investigation workflow without setting up the project locally.

GitHub repository: Harsh-0986/LogSherlock

LogSherlock is open source under the MIT License. Contributions, bug reports, and ideas for additional parsers or model providers are welcome.

The project combines deterministic log processing with a bounded AI investigation workflow.

The investigation pipeline is designed to keep each step understandable:

The deterministic parts still work when an AI model is unavailable. The report can indicate partial results rather than pretending that a complete AI investigation succeeded.

My current backend suite contains 189 tests, and the frontend type checks, lint checks, and production build have passed. I also verified an end-to-end AI investigation once, including findings with valid citations across three error groups. That is a useful milestone, but it does not prove the hosted AI path is consistently reliable.

There is still work to do: hosted-model reliability needs more testing, PostgreSQL persistence has not yet been verified against a real PostgreSQL instance, and browser-level end-to-end testing is incomplete.

I wanted the investigation engine to be replaceable rather than tied to one closed AI API.

Open-weight models and local inference make it possible to experiment with different models, run investigations on a developer’s own machine, and keep sensitive logs local when the entire processing path is configured locally.

That matters because logs can contain internal service names, customer information, stack traces, and occasionally secrets. LogSherlock includes redaction, but redaction is best-effort, so keeping inference local is an important option—not a guarantee that every sensitive value will be caught.

Open-source tooling also makes the workflow inspectable. Developers can review how errors are grouped, how severity is ranked, and how citations are validated. They can extend parsers, add model providers, or challenge the approach instead of treating the debugging result as a black box.

For this project, open innovation is not just about avoiding API costs. It is about giving developers more control over their debugging workflow, their data, and the models they choose to run.

Built for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.