At $600 an hour, a forensic accountant will spend six weeks reading your documents. I built a desktop app that does it in minutes for $5.

A client came to me with a problem I suspect a lot of businesses share: thousands of financial documents sometimes in multiple languages - invoices, receipts, bank statements, salary slips, contracts - spread across folders and email. They needed to understand what was actually in there.

Most businesses in this situation do one of two things: pay someone to manually sort through it all, or just live with the mess. If you actually want analytical depth - cross-referencing documents, finding what's missing, detecting anomalies - that's forensic accounting territory. Typical rates run $300–600 per hour. An investigation runs $15,000–100,000+. For most businesses, that's not even a conversation worth having.

So I built them a desktop app instead.

What I Built

Clouseau is a desktop app for macOS and Windows that ingests, OCRs, summarises, and lets you interrogate a multilingual document corpus using AI.

It handles the full range of formats a real business produces - PDFs, emails, spreadsheets, messages, exports from Google Workspace. The OCR isn't traditional character recognition. Claude's vision capability actually reads and understands the documents - printed text, handwritten notes, post-it annotations, margin scribbles - extracting structured metadata at ingest: document type, date, monetary amounts, currencies, parties involved, reference numbers. A Thai invoice gets the same treatment as an English contract - parsed, typed, dated, and indexed. A handwritten note on a bank statement gets read alongside the statement itself.

The ingest pipeline runs in four stages. Documents are registered, then processed through vision-based OCR, batch-summarised to create a structured index, and optionally converted into searchable PDFs via Tesseract. A corpus of ~10,000 documents goes from raw files to fully queryable in a few hours, with progress tracking and the ability to pause and resume.

Everything runs on the client's machines - no cloud storage, no third-party indexing.

Starting at the Ceiling

I deliberately took an extreme approach first. Before thinking about cost or speed, I wanted to answer one question: what's the absolute best quality result you can get from AI today? What does bleeding edge actually look like when you throw everything at a problem and don't worry about the bill? (I often find myself doing this 😄)

So I built brute-force forensic analysis. For each query, send every single selected document across the corpus to Claude for individual relevance assessment. No embedding approximation, no retrieval cutoffs, no shortcuts. The system fans out across folders in parallel, chunks documents to respect context limits, and has Claude score each document on a 1–10 scale with written reasoning explaining exactly why it's relevant or not.

Here's what you can ask it:

• "Find every salary payment that doesn't match the employment contract amount, or that's missing from the payroll register entirely."

• "Which expense vouchers have no matching receipt? Of those, which are for suspiciously round amounts or fall just below the approval threshold?"

• "Here's an external audit report with 12 findings. For each one, which documents in our corpus support it, which contradict it, and which findings have zero supporting evidence?"

• "These payments are dated after we know the account was frozen. Cross-reference the bank statements and tell me if the timeline is even possible."

These aren't keyword searches. They require reasoning across document types, detecting the absence of expected documents, comparing values between different records, and understanding temporal relationships.

An optional Deep Dive mode goes further - four independent analysis passes that test and attack the findings. A skeptic challenges every claim, flagging single-document dependencies. A referee resolves conflicting documents using an evidence hierarchy (bank statements outweigh internal vouchers, which outweigh memos). A red team constructs the strongest possible counter-argument to each finding. A confidence scorer quantifies how much you should actually trust each conclusion, flagging when a finding relies on a single source or when OCR quality is uncertain.

A single forensic scan of the full ~10,000-document corpus costs roughly $200 in API calls (or about $5 on Claude Max). That sounds expensive for a single search query. But it equals maybe less than 30 minutes of a forensic accountant's time - except instead of one person skimming a few documents, every single document has been individually assessed with written reasoning you can audit.

This was deliberate. I wanted to establish the quality ceiling before figuring out how to bring the cost down.

Making It Practical

Once I knew what ‘perfect’ looked like, I could build a fast mode that gets 90% of the way there in seconds for pennies. Local embeddings running entirely on-device - no cloud service - combined with keyword matching and semantic vector search. Claude synthesises the top results into a narrative answer with specific document references.

This is what you'd actually use day-to-day - ask questions, get answers, explore your documents.

The forensic scan stays for when you need certainty. Found something interesting in a quick search? Switch to forensic mode on that specific folder or document set. A focused forensic scan on 200 documents is fast and cheap - you're not paying for full cross-corpus analysis, you're drilling into a specific area. The two modes work well together.

There's also a proactive deep corpus audit that scans everything without you asking a question. It flags anomalies - suspicious spending patterns, missing document sequences, expense claims without supporting receipts, transactions that skirt just below approval thresholds, vendors who also appear as employees. The kind of things a forensic accountant looks for, running automatically.

And there’s a knowledge base about your business specifics which the queries use for guidance. It can even populate a first draft of this from your documents.

How This Differs From NotebookLM

NotebookLM and similar tools are 'upload and chat'. They work well for a handful of documents and straightforward questions. Clouseau is built for a fundamentally different problem.

Scale and structure. Thousands of documents across multiple formats, not a dozen PDFs. Every document has extracted metadata - type, date, amounts, parties - that you can filter, cross-reference, and scope queries against. It's a structured index, not a blob of text.

Evidence classification. Search results are tagged as supporting, contradicting, contextual, or tangential. When you ask a question, you don't just get 'here are some relevant documents'. You get an explicit breakdown of what supports a question and what contradicts it.

Absence detection. The corpus audit flags what's missing. Gaps in document numbering. Months without salary records. Expense claims without receipts. No retrieval-based system finds things that don't exist - but often you need a system that understands what should be there.

Adversarial testing. The Deep Dive doesn't just answer your question - it attacks its own answer, scores its confidence, and tells you exactly where the reasoning is weakest. You don't get this from off-the-shelf tools because the compute cost per query is absurd by consumer standards.

Privacy. No cloud storage, no third-party indexing, no question of who else has access to your financial records.

The Use Case Shift

Forensic document analysis has always been a reactive, expensive service. Something's gone wrong. You suspect fraud, or you're being audited, or you're in litigation. You hire specialists. They bill by the hour. The engagement costs more than most small businesses spend on accounting in a year. You use this service once, maybe twice, mostly never in a company's lifetime.

At $5 a scan, the story changes.

A financial controller can run monthly anomaly scans instead of waiting for year-end surprises. The system catches spending pattern shifts, vendor concentrations, threshold-skirting, payroll inconsistencies - the kind of early signals that prevent problems from becoming crises.

A business owner who has never been able to read their own Japanese financial records can now ask questions in English and get answers that cite specific documents, dates, and amounts. They can actually understand their own business.

A lawyer can upload opposing counsel's allegations and gets an automatic evidence map in minutes - which documents support each claim, which contradict it, and which claims have no documentary basis at all.

A company facing a tax audit can match every query from the revenue department to its supporting documents in hours, not the weeks of panicked file-pulling that usually follows a notice.

For Accountancy and Law Firms

It's obvious where this goes. An accountancy practice already has the client relationships and the domain expertise - they could wrap document intelligence into their existing services for SME clients who would never commission a £50,000 forensic audit but would pay for a monthly financial health report. A law firm doing due diligence could ingest a data room and query it in natural language instead of billing associates to read every page.

Previously, the quality of financial document analysis you could get was directly proportional to how much you could spend on human specialists. That's not true anymore.

Building It With Claude Code

A few notes on the build.

This was my first desktop app. I'd never built a native desktop application before. Python gave me the backend, pywebview provided the native window on both macOS and Windows, and PyInstaller handled packaging. Claude Code dealt with the complexity I'd have spent days on - path resolution between bundled and development modes, native file picker integration.

The architecture emerged from use, not upfront design - rapid application development is so back! The fan-out parallelism across folders came from 'this query is too slow.' The model-specific rate limiting (three concurrent Opus calls, ten Sonnet, fifty Haiku) came from hitting API limits. The token-aware chunking - exact counts via the API, cached in the database, with a heuristic fallback for offline use - came from context window overflows. Building the forensic mode first meant the infrastructure was already designed for the hardest case. When I added the fast RAG mode later, the foundations were there.

Eleven specialised prompts, each refined against real multilingual financial documents. The adversarial Deep Dive pipeline was designed specifically because single-pass analysis produces confident-but-wrong answers more often than you'd like.

The whole system was functional within days and genuinely useful to the client within weeks. Claude Code made this viable as a focused project rather than a multi-month engineering effort.

You can read more about it at https://clouseau.pm