SlopTotal

VirusTotal for AI-generated text. Paste text, drop in a PDF or Word file, or
give it a URL. Twenty-three independent AI detectors (neural classifiers,
statistical tests and linguistic heuristics) score it in parallel, and a
calibrated ensemble turns their votes into one verdict you can inspect engine by
engine. It runs on your own CPU, so nothing you scan leaves your machine.

It is a free, self-hosted, open-source alternative to hosted AI content
detectors such as GPTZero, Originality.ai, Copyleaks, ZeroGPT and Humalingo.
Instead of one number from one model, it shows you every model's opinion, and
it publishes how accurate that is, failures included.

Try it: sloptotal.com · Run it: docker run -p 8000:8000 ghcr.io/pablocaeg/sloptotal

Features

• 23 detection engines, one calibrated score. DeBERTa and RoBERTa
  classifiers, Binoculars, Fast-DetectGPT, GLTR, perplexity and burstiness
  tests, and stock-phrase heuristics. Results stream in as each engine finishes.
• Text, URLs and documents. Paste text, scan a web page (main content is
  extracted automatically), or upload .pdf, .docx, .txt or .md.
• Site check: was this website vibe-coded? Finds the fingerprints that
  Lovable, v0, Bolt, Base44, Replit and Same leave in the sites they deploy,
  and shows the evidence for each one. How it works
• Per-paragraph heat map through the API, to see which parts read as AI.
• Measured, not claimed. Every accuracy number below comes with the corpus,
  the harness and the raw per-sample scores.
• Private by default. Self-hosted, no third-party AI APIs, no tracking,
  reports deleted after 30 days.
• CPU-only is fine. Auto-detects your hardware; 4 GB RAM is enough for the
  lite profile, a GPU is optional.
• JSON API and a Chrome extension
  that marks AI-looking results in Google Search and LinkedIn.

Measured accuracy

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.

Re-measured in September 2026 on a fresh RAID sample (180 texts) with upgraded
dependencies: AUC 0.979, 1 of 40 human texts called "Likely AI", 0 of 26
literary passages flagged.

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/.

Quick start

Docker (fastest)

docker run -p 8000:8000 -v sloptotal-models:/app/models ghcr.io/pablocaeg/sloptotal

Open http://localhost:8000. The first scan downloads about 2 GB of models into
the sloptotal-models volume, so later starts are quick. To build from source
instead, run docker compose -f docker/docker-compose.yml up.

From source

Requires Python 3.10+ (macOS ships 3.9, which is too old).

git clone https://github.com/pablocaeg/sloptotal.git
cd sloptotal
python3.11 -m venv venv && source venv/bin/activate
pip install -r requirements.txt
./scripts/start.sh    # or: uvicorn app.main:app --port 8000

Check that every engine loads and scores, end to end:

python scripts/smoke_test.py          # against http://localhost:8000

Site check: detect sites built with AI app builders

"Is this website vibe-coded?" checkers mostly score style (Tailwind class
counts, missing security headers, buzzwords) and turn it into a percentage.
Hand-written sites share all of those traits. SlopTotal looks only for markers
the builders themselves leave in what they deploy, each one confirmed on live
sites or in the builders' own templates:

A site with no marker may still have been written with AI: code exported from
these tools and hosted elsewhere, or written in an AI editor, carries no
fingerprint. So the result is evidence, not a probability. The page's copy is
scored separately by the text engines.

curl -X POST http://localhost:8000/api/scan/site \
  -H "Content-Type: application/json" -d '{"url": "example.com"}'

API

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

From Python, examples/python_client.py analyses a
text, prints the five engines scoring highest and runs a site check, waiting
in the queue when the server is busy:

python examples/python_client.py "Paste at least 50 characters of text here..." example.com

The response lists every engine with its score, verdict and a plain-language
detail line, plus overall_score (0-100) and overall_verdict.

Detection Engines

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.

Neural Classifiers

Statistical Methods

Linguistic Heuristics

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.

Scoring

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.

Configuration

SlopTotal detects CPU, RAM and GPU at startup and picks a profile. Everything
can be overridden with environment variables; see .env.example.

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
./scripts/start.sh

FAQ

Can AI detectors be trusted? Not blindly. No detector, this one included,
should be the only evidence for an accusation. That is why SlopTotal shows
all 23 votes, how much they agree, and its measured false-positive rate. Short
text (under about 80 words) and heavily edited AI text are unreliable for every
detector.

Does it detect ChatGPT, Claude, Gemini, Llama and Mistral? The evaluation
corpus includes GPT-4, ChatGPT, Llama and Mistral output. The classifiers were
trained on a wider mix. Newer models are covered as far as they share those
fingerprints; the evaluation harness lets you measure any model
you care about.

Will it flag classic literature or formal writing? Not in our tests: none
of the 26 passages from Austen, Melville, Kafka, Machiavelli and others is
flagged. Pre-1920 prose is part of the evaluation precisely because naive
detectors fail on it.

Is my text stored or shared? It is processed on the server you run. Reports
are kept for 30 days (configurable) so report links work, and nothing is sent
to an outside service.

Can it detect AI-generated code? No, and we do not claim it can: in testing
the engines never flagged human code but never caught machine-written code
either. The Site check reports which AI app builder produced a website, which is
a different question.

Troubleshooting

Project layout

app/            FastAPI backend: engines, ensemble, site fingerprints, API
web/            The web UI (Jinja2 templates, vanilla JS, no build step)
tests/          Unit tests (seconds, no downloads) and tests/eval/ accuracy harness
scripts/        smoke_test.py (end-to-end) and the model drift check
benchmarks/     Speed and load scripts

ARCHITECTURE.md covers the internals. AGENTS.md
is a short brief for contributors and AI coding assistants.

Newer open detectors we measured

Detector models keep appearing on Hugging Face, each with its own accuracy
claim. Before adding any, we score them on the same two corpora. September 2026,
standalone, 180 RAID texts plus the 26 literary passages:

RAID-trained models score near 1.0 on RAID by construction and need a different
test set first. The full table, the models we excluded and why, and the raw
scores are in tests/eval/FINDINGS.md.
The roadmap is in TODO.md.

Related projects and reading

• RAID benchmark (ACL 2024): adversarial AI text detection dataset used in our evaluation
• Detecting the Machine (2026): cross-architecture detector benchmark; ensembles beat single detectors
• EditLens: human vs AI-edited vs AI-generated classification
• GLTR: visual token-rank inspection, the inspiration for our GLTR engine
• distil-labs/distil-ai-slop-detector: a 270M Gemma detector that runs in the browser
• sloptotal-extension: the Chrome extension

Contributing

Contributions are welcome, especially new engines with measurements. Start with
CONTRIBUTING.md.

• Report a bug
• Request a feature
• Propose a new engine
• Ask a question or share results

If SlopTotal is useful to you, a star helps other people find it.

License

MIT. Model weights keep their own licenses; see
THIRD_PARTY_LICENSES.md.