How to Detect AI Slop: 5 Open-Source Tools to Build Your Own Detector

You detect AI slop by combining a statistical text classifier, a watermark check, and a bot-traffic filter into one pipeline you run yourself, not by paying a SaaS vendor per word scanned. Five open-source tools do the job: Binoculars, Fast-DetectGPT, ZipPy, SynthID, and a stack of anti-bot tools like BotD and Anubis.

Why detection suddenly matters

AI slop is content made with generative AI that reads as low-effort, low-quality, or built purely to farm engagement rather than inform anyone.¹ It stopped being a meme problem sometime in the last two years. Graphite analyzed 65,000 English-language URLs from Common Crawl going back to 2020 and found AI-generated articles briefly overtook human-written ones in November 2024. By May 2025, AI content made up roughly 52% of newly published web articles, up from about 2.2% in January 2020.²³

The submission side of the internet feels it too. Clarkesworld, the science fiction magazine, saw story submissions more than double at the peak of AI-generated spam, much of it driven by "get rich quick" schemes circulating on YouTube and TikTok.⁴ The editor has kept adapting his screening process ever since, and the magazine still received 14,805 submissions in 2025, averaging over 1,200 a month.⁵ If a niche literary magazine needs a standing filter, so does any platform that accepts user-generated content, reviews, forum posts, or agent-submitted data.

Why doesn't the SaaS detection market fit this problem?

Commercial detectors like GPTZero, Originality.ai, and Copyleaks were built for one job: checking whether a single student's essay or a single freelancer's article was written by a human. That's a single-document, low-volume use case, and the pricing reflects it. Originality.ai's Enterprise plan runs $136.58 a month for high-volume checking, structured around per-word or per-credit consumption.⁶ Scale that to a platform screening thousands of submissions, comments, or agent outputs a day, and the bill stops looking like a rounding error.

Accuracy is the other problem. These vendors market roughly 99% accuracy, but independent testing tells a messier story: GPTZero lands around 80-91% in practice, Originality.ai 85-92%, and Copyleaks anywhere from 74-94% depending on the sample, with false positive rates as high as 5.7-7% despite claims of under 1%.⁶ GPTZero's own head-to-head benchmark reports 99.3% accuracy and a 0.24% false positive rate against Copyleaks, which just underscores that even vendor-run tests disagree with each other.⁷ There's no single source of truth here, paid or free. That's an argument for owning the detection logic instead of outsourcing your judgment to a black box you can't inspect.

The build-vs-buy case for owning your own detector

A self-hosted slop detector costs engineering time instead of a subscription, and it can be tuned to your own content patterns rather than a generic academic-essay benchmark. That's the same logic driving the broader open-source infrastructure shift right now, where teams are pulling entire categories of rented tooling in-house because the tools have gotten good enough and the ops burden has dropped.Build vs. Buy in 2026: The Open-Source Infrastructure Boom You don't need to match a commercial vendor's marketing claims. You need something that catches the specific slop hitting your specific pipeline, and that you can retrain or retune without a vendor's roadmap in the way.

Here are the five tools that make that possible.

1. Binoculars: zero-shot detection with no training data

Binoculars is a zero-shot, domain-agnostic method that needs no training data at all.⁸ It works by running text through two closely related pretrained LLMs and contrasting their perplexity scores; human writing and machine writing produce different signatures under that comparison. The published numbers are striking: over 90% detection of ChatGPT and other LLM-generated text at a false positive rate of just 0.01%.⁸⁹ That false positive rate matters more than the headline accuracy number. A detector that flags 1 in 10,000 real users instead of 1 in 20 is the difference between a useful filter and a support-ticket generator. Binoculars is the closest thing on this list to a flagship general-purpose text detector, and it's the one worth standing up first.

2. Fast-DetectGPT: efficient curvature-based detection

Fast-DetectGPT, published at ICLR 2024, is a faster, cheaper descendant of the original DetectGPT approach.¹⁰ Instead of expensive perturbation sampling, it estimates conditional-probability curvature directly, which cuts compute cost substantially while staying zero-shot, no fine-tuning per model needed. If Binoculars is your accuracy baseline, Fast-DetectGPT is what you reach for when you need to run detection at volume without burning a GPU budget on every submission.

3. ZipPy: compression-ratio detection for lightweight filtering

ZipPy, built by security firm Thinkst, skips large language models entirely. It classifies text as AI- or human-generated using LZMA, zlib, or Brotli compression ratios as a stand-in for perplexity.¹¹ Compression algorithms compress predictable, low-entropy text more efficiently, and AI-generated text tends to be more compressible than human writing. It's not the most accurate tool here, but it's the lightest: pip-installable, packaged with browser extensions, and cheap enough to run on every inbound request instead of a sample. Good as a first-pass filter ahead of something heavier like Binoculars.

4. SynthID: watermark-based detection for text and images

Google DeepMind open-sourced SynthID Text in October 2024, letting any team watermark and later detect text generated by their own models.¹² Detection works by comparing the expected probability scores for words during generation against the words that actually appear.¹³ The catch: it only works on text your own models produced with the watermark embedded, so it's a provenance tool, not a general slop detector. For images and video, the equivalent is C2PA, an open standard backed by Adobe, Google, and Microsoft that embeds cryptographic Content Credentials proving or disproving AI origin. Open-source projects like origin-lens implement C2PA verification for free.¹⁴ Neither replaces statistical detection, but both add a second, independent signal when you control the generation side.

5. Open-source bot and traffic filters

AI slop isn't only generated text sitting still on a page. A growing share of it arrives as automated agent traffic: scraper floods, fake account signups, bulk submission bots. BotD does client-side bot fingerprinting in the browser, Anubis makes scrapers solve a proof-of-work challenge before they get through, and Fail2Ban bans IPs based on log patterns.¹⁵ None of these read the content of a submission. They filter the traffic pattern around it, which catches slop that a text classifier alone would miss entirely. This matters more as more of that traffic is agent-driven rather than human, the same shift covered in Build vs. Buy in the Agent Era: Orchestrating Your Own Office of Clones.

How do you stack these into one pipeline?

No single tool here is a complete answer. The pattern that works is layering:

1. Traffic filter first. Run BotD or Anubis at the edge to strip out obvious bot and scraper traffic before it ever reaches your content pipeline.
2. Fast pre-screen. Run ZipPy or a similar compression-based check on everything that gets through, since it's cheap enough to apply universally.
3. Accurate second pass. Send anything ZipPy flags, or a sampled portion of everything, through Binoculars or Fast-DetectGPT for a stronger statistical read.
4. Provenance check where relevant. If you control the generation side, check SynthID watermarks on text and C2PA credentials on images to confirm or rule out origin.
5. Human review on the edge cases. Anything the pipeline flags with low confidence goes to a person, not an auto-reject.

This is roughly the same architecture teams already use for internal agent orchestration and AI gateways: layered checks with a human backstop rather than one model deciding everything.Self-Hosted AI Gateway vs. SaaS: The Real Build vs. Buy Math The tools here are small enough that most of this can run on infrastructure you already have.

Where this still falls short

Be honest about the limits before you ship this. Independent testing of even the best-funded commercial detectors shows real-world accuracy landing well below marketing claims, 80% to 94% rather than the advertised 99%, with false positive rates that can climb into the single digits under adversarial conditions.⁶ Nothing here changes that math for the open-source tools either. Detection is an arms race: as detectors improve, so do the paraphrasing tools built specifically to evade them, and a determined bad actor with access to Binoculars' own paper can design around it. Watermark-based tools like SynthID only work on content generated with the watermark on, which means they're useless against slop from a competitor's model or an older unwatermarked version. And false positives carry real cost: wrongly flagging a human writer's work erodes trust fast.

If you're running a single-document, low-volume check, say, verifying one contributor's article before publication, a paid tool with a support team and an appeals process might still be the right call. But for platforms filtering thousands of submissions, comments, or agent-generated records a day, the economics flip. A stacked, self-hosted pipeline built from Binoculars, Fast-DetectGPT, ZipPy, SynthID, and open bot filters costs engineering hours, not a per-word invoice, and you can retune it the moment your own slop patterns change. That's the tradeoff worth making.