VirusTotal for AI slop detection. Scan any text or URL with 23 independent detection engines running entirely on your hardware. No data sent to third parties.

SlopTotal runs 23 AI detection engines in parallel -- neural classifiers, statistical tests, and linguistic heuristics -- and produces a calibrated forensic score. Results stream in real-time as each engine completes.

Live demo: sloptotal.com — or read the per-engine scores and what the measurements show.

Most detectors publish an accuracy figure without saying what it was measured on. These numbers, the harness that produced them and the raw per-sample results are all in tests/eval/.

Two corpora, deliberately:

The second exists because a high score there cannot be anything but an error: the writing predates language models by a century or more. Optimising on the first corpus alone produces a threshold that mislabels literature.

What does not work. Short text is unreliable below roughly 80 words and settles from about 200. Hand-edited AI loses fingerprints with every rewriting pass. Source code is outside what these engines do: in testing they never falsely accused human code, and never caught machine-written code either -- so we do not claim they can.

The failures are published too, including three engines found scoring backwards and two loading a randomly initialised network while carrying real ensemble weight. Read them at sloptotal.com/detect/ai-detector-benchmark/ and sloptotal.com/detect/ai-detector-false-positives/.

• Python 3.10+ (3.11 recommended — macOS ships 3.9, which is too old)
• 4 GB RAM minimum (lite profile); 8 GB standard; 16 GB+ for best CPU throughput
• No GPU required — all engines run on CPU; CUDA optional for faster inference
• ~2 GB disk for HuggingFace model cache on first run

# Clone and install
git clone https://github.com/pablocaeg/sloptotal.git
cd sloptotal

# Use Python 3.10+ explicitly (example: Homebrew on macOS)
python3.11 -m venv venv && source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

# Optional: copy env template
cp .env.example .env

# Start (auto-detects hardware, downloads models on first run)
./start.sh
# or manually:
uvicorn app.main:app --host 0.0.0.0 --port 8000

Open http://localhost:8000 in your browser.

Re-scanning the same URL? Results are cached by content hash. After upgrading dependencies, stale failure reports are purged automatically on startup. Run a fresh scan if you previously saw "Model loading failed".

docker compose up

sloptotal/
├── app/                    # Backend (Python/FastAPI)
│   ├── main.py             # App factory, lifespan, middleware
│   ├── routes/
│   │   ├── web.py          # Web page routes (/, /report, /analyze, SSE)
│   │   ├── api.py          # JSON API (/api/quick-score, /api/analyze, etc.)
│   │   └── queue.py        # Queue status & ticket polling
│   ├── analyzer.py         # Core analysis orchestration & scoring
│   ├── engines/            # 23 detection engines
│   │   ├── base.py         # BaseEngine ABC
│   │   └── ...             # One file per engine
│   ├── config.py           # Configuration & engine weights
│   ├── schemas.py          # Pydantic models
│   ├── database.py         # SQLite async storage
│   ├── cache.py            # Content hashing & caching
│   ├── scraper.py          # URL content extraction
│   ├── autoconfig.py       # Hardware detection & profiling
│   ├── model_pool.py       # Thread-safe model replica pools
│   └── queue_manager.py    # Request queuing & backpressure
├── web/                    # Web Frontend
│   ├── templates/          # Jinja2 templates
│   └── static/             # CSS, JS, images
├── extension/              # Chrome Extension (Manifest V3)
│   ├── manifest.json
│   ├── background.js
│   ├── popup/
│   └── content/
└── tests/                  # Evaluation scripts

curl -X POST http://localhost:8000/api/quick-score \
  -H "Content-Type: application/json" \
  -d '{"text": "Your text to analyze here..."}'

Response:

{
  "score": 72.3,
  "verdict": "ai",
  "confidence": "high",
  "engines": [...],
  "elapsed_ms": 340.2
}

Every engine links to its page on sloptotal.com, which carries its measured scores against both corpora. AUC below is the probability the engine ranks a random AI passage above a random human one: 1.0 is perfect, 0.5 is a coin flip.

The linguistic heuristics are weak on their own. They are kept because they fail independently of the neural classifiers, which is what makes them useful as tiebreakers rather than as evidence.

The final score is calibrated, not a simple average, and every weight is derived from measurement rather than intuition. See tests/eval/FINDINGS.md and sloptotal.com/detect/ai-detector-ensemble/.

1. Anchored on the unbiased classifiers -- Desklib, SuperAnnotate, E5 and ReMoDetect all score high AUC with no measurable bias against older prose. Their consensus is blended 60/40 with the full weighted set.
2. Weights from measurement -- each engine's share is proportional to Somers' D (2*AUC - 1), scaled down by any bias it shows against archaic writing. RAID-trained engines are damped because our corpus is RAID.
3. Confidence from agreement -- a tight cluster across independent engine families is trustworthy; one confident engine is not.
4. Skepticism, but only when earned -- unanimous high classifier scores are damped only when the text itself carries human markers (contractions, first-person, slang). Applied unconditionally it fired on 69 of 70 AI samples and 0 of 66 human ones, suppressing correct detections.

Fakespot was previously the anchor, weighted 0.13. It is accurate on modern text (AUC 0.999) but scored pre-1920 human prose at 0.645 against 0.112 for modern human writing -- the largest bias of any engine -- and anchoring amplified it. Machiavelli scored 62.5. After demotion to 0.033, literary passages average 10.2 and none is flagged.

SlopTotal auto-detects CPU, RAM, and GPU on startup and picks a profile (lite, standard, or performance).

High-RAM CPU servers (e.g. 64 GB, no GPU): you automatically get the performance profile. With no CUDA, all inference stays on CPU but you can run more concurrent workers and model pool replicas:

# Tune for a 64 GB CPU-only server
export SLOPTOTAL_PROFILE=performance
export SLOPTOTAL_TORCH_THREADS=8
export SLOPTOTAL_FULL_WORKERS=8
export SLOPTOTAL_SNIPPET_WORKERS=6
export SLOPTOTAL_MAX_CONCURRENT_FULL=4
export SLOPTOTAL_POOL_FAKESPOT=2
export SLOPTOTAL_POOL_TMR=2
./start.sh

First full scan downloads ~2 GB of models and may take 1–2 minutes while weights load; subsequent scans are much faster.

Hardware is auto-detected on startup. Override with environment variables:

SLOPTOTAL_TORCH_THREADS=4
SLOPTOTAL_FULL_WORKERS=6
SLOPTOTAL_SNIPPET_WORKERS=4
SLOPTOTAL_MAX_CONCURRENT_FULL=3

Verify all engines loaded:

curl -s http://localhost:8000/health | python3 -m json.tool
# Expect: "status": "healthy", "engines": 23

See TODO.md for planned engines — including Qwen and Gemma classifiers and perplexity models optimized for high-RAM CPU servers.

Similar tools

• distil-labs/distil-ai-slop-detector — 270M Gemma model, runs in the browser
• Flamehaven01/AI-SLOP-Detector — static analyzer for AI-generated code (complementary to text detection)
• GLTR — visual token-rank inspection (inspiration for our GLTR engine)

Papers & benchmarks

• RAID benchmark (ACL 2024) — adversarial AI text detection dataset; several SlopTotal engines are RAID-trained
• Detecting the Machine (2026) — cross-architecture detector benchmark; ensemble methods outperform single detectors
• EditLens / Greyscope — human vs. AI-edited vs. AI-generated classification (candidate Qwen engine)

Guides

• Detecting AI Slop: Techniques & Red Flags — perplexity, classifiers, and ensemble approaches

The SlopTotal Chrome extension is maintained as a separate open-source repository:

pablocaeg/sloptotal-extension

Features:

• Scans Google search results inline with AI probability badges
• Scans LinkedIn feed posts with AI detection
• Quick-score popup for any page or selected text
• Right-click context menu integration
• Configurable API — point at any SlopTotal backend

Install from the extension repo or load extension/ as an unpacked extension for development.

This project ships with 11 specialized AI agents that can autonomously navigate, build, test, review, and ship contributions. They work with any AI coding assistant — Claude Code, Cursor, GitHub Copilot, ChatGPT, Gemini, Windsurf, or programmatic API calls. Anyone who clones this repo gets access to them automatically.

sloptotal-expert          # Understand the codebase
sloptotal-completionist   # Find what's missing or broken
sloptotal-feature-builder # Build new engines, endpoints, pages
sloptotal-test-writer     # Create tests with proper patterns
sloptotal-reviewer        # Code review before PR
sloptotal-optimizer       # Performance, SEO, accessibility
sloptotal-deployer        # CI/CD and deployment
sloptotal-open-source     # GitHub templates and discoverability
sloptotal-extension-extractor  # Extract extension to its own repo
sloptotal-pr-creator      # Git workflow and PR creation
sloptotal-contribute      # Master orchestrator for end-to-end workflows

See docs/ai-agents/ for full documentation, workflow pipelines, and usage examples.

Contributions are welcome! See CONTRIBUTING.md for development setup, code style, and how to add new detection engines.

• Bug Report
• Feature Request
• Propose a New Engine

MIT