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, Same and Emergent 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; a GPU is optional. Loaded
models need about 8.3 GB of RAM (an estimate; see
docs/MODELS.md).
- 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. SlopTotal is measured on SlopBench: 1,626 human
texts, every one written before ChatGPT, and 1,626 AI texts on the same topics
and at the same lengths from 14 current models, across 15 kinds of writing
(news, Wikipedia, arXiv, Stack Exchange, Reddit, reviews, student essays,
non-native English, fiction and literature published 1532-1915). Every number
below is measured on kinds of writing the model was not tuned on.
| |
|---|
| AUC | 0.942 |
| AI texts called "Likely AI" (55+) | 67% |
| Human texts called "Likely AI" (55+) | 1.7% |
| Human texts flagged at all (45+) | 3.9% |
| Literature published 1532-1915 flagged | 0 of 87 |
The score bands are anchored on that human text: 45 is where the top 5% of
human writing begins, 55 the top 2%, 80 the top 0.5%. So "Likely AI" means
fewer than 2 in 100 human texts score this high.
Other languages. Spanish, French, German, Italian, Portuguese, Dutch,
Polish, Russian and Japanese are supported (AUC 0.91 to 0.997); Arabic and
Korean are experimental; Hindi, Turkish and Chinese are not reliable yet, and
the report says so.
What does not work. Essays by non-native English writers are still flagged
more than native ones (15% of TOEFL essays called Likely AI, against none of 88
US school essays). Under about 80 words a score is a weak signal. AI text run
through a "humanizer" is caught about half the time. Source code is outside
what these engines do. All of it, per source, per model and per engine, is in
the findings, including that the
classifiers which top the RAID benchmark drop to AUC 0.75 on current models.
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 9 GB of models
(see docs/MODELS.md) 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:
| Builder | Fingerprints |
|---|
| Lovable | gptengineer.js runtime, /lovable-uploads/ assets, the Lovable badge, /~flock.js, *.lovable.app |
| v0 (Vercel) | <meta name="generator" content="v0.app"> from v0's layout template, *.vusercontent.net |
| Bolt | X-Powered-By: Bolt.new header, bolt.new/badge.js, *.bolt.host |
| Base44 | app.base44.com platform calls, base44_access_token, *.base44.app |
| Replit | Replit Agent dev banner, Replit badge, *.replit.app |
| Same | assets served from same-assets.com |
| Emergent | __emg_sid and __emg_vid cookies, emergent-main.js script, *.emergent.host |
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
| Endpoint | Method | What it does | Typical latency (CPU) |
|---|
/api/analyze | POST | Full 23-engine report for text or url | 2-8 s |
/api/quick-score | POST | 4 classifiers plus heuristics | 0.1-0.5 s |
/api/paragraph-score | POST | Score per paragraph (heat map) | 1-3 s |
/api/scan/site | POST | AI app builder fingerprints plus a copy score | 1-3 s |
/api/extract | POST | Text from an uploaded .pdf / .docx / .txt (multipart file) | < 1 s |
/api/scan/snippets | POST | Batch of 1-30 short snippets | ~0.5 s |
/api/scan/urls | POST | Batch of 1-10 URLs, page-type aware | 1-5 s |
/api/engines | GET | Engine metadata | instant |
/api/report/{id} | GET | A stored report | instant |
/api/report/{id}/feedback | POST | Record who actually wrote the text: {"label": "human" | "ai" | "mixed" | "unsure"} | instant |
/api/queue/status | GET | Queue capacity | instant |
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.
From Node 18+, examples/node_client.mjs uses the
built-in fetch to analyse a text and print the overall score, the verdict and
the five engines scoring highest. Pass --base to point it at another server:
node examples/node_client.mjs "Paste at least 50 characters of text here..." --base http://localhost:8000
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
| Engine | Model | AUC | Notes |
|---|
| Desklib DeBERTa | DeBERTa-v3-large (435M) | 1.000 | Strongest separation in our own tests |
| SuperAnnotate | RoBERTa-large (355M) | 0.989 | No measurable bias against archaic prose |
| E5-Small | E5 + LoRA (33M) | 0.999 | Matches far larger models at 33M params |
| TMR Detector | RoBERTa-base (125M) | 1.000 | RAID-trained, so RAID scores flatter it |
| BERT-tiny RAID | BERT-tiny (4.4M) | 1.000 | Answers in milliseconds |
| ReMoDetect | DeBERTa (184M) | 0.941 | Targets RLHF-aligned LLMs |
| ChatGPT Detector | RoBERTa-base (125M) | 0.829 | ChatGPT-specific |
| Fakespot | RoBERTa-base (125M) | 0.999 | Accurate on modern text, but +0.533 bias on pre-1920 prose |
| OpenAI Detector | RoBERTa-base (125M) | 0.771 | The 2019 GPT-2 detector; weaker on modern LLMs |
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 overall score is a logistic model over the engine scores, fitted on
SlopBench. The fitted parameters are in
app/calibration.json, and every number in the fit's
report, tests/eval/slopbench/FINDINGS.md, is
measured on kinds of writing the fit never saw. docs/CALIBRATION.md
explains each field in the JSON and how to regenerate it.
- Weights from a fit, not by hand. Each engine's score is turned into
log-odds and weighted by the model, with weights kept non-negative. An engine
earns weight only for what it adds once the others are known, so engines that
fail together do not count twice. In English, 8 of the 23 engines carry
weight (Structural, Desklib, Fakespot, SuperAnnotate, Formulaic, Readability,
Binoculars and Burstiness). The other 15 add nothing on top of them, and every
one is still shown in the report.
- Bands set on human text. The output is mapped so that 45 is where the top
5% of human texts begin, 55 the top 2% and 80 the top 0.5%.
- Short texts held back. Short English texts are pulled toward a neutral
score by
words / (words + 5); other languages use a fitted short-text term.
Scripts written without spaces (Chinese, Japanese, Thai and others) skip it.
- Other languages. A separate fit with a per-language offset, placed so 5%
of human text scores above 45, and a support status: supported for German,
Spanish, French, Italian, Japanese, Dutch, Polish, Portuguese and Russian;
experimental for Arabic and Korean; not yet reliable for Hindi, Turkish and
Chinese.
- Confidence from the score. Low under 80 words, in a language that is not
yet reliable, or between 35 and 65; medium in an experimental language or
between 15 and 80; high otherwise.
Up to v1.1 the score was a hand-weighted blend anchored on four classifiers.
tests/eval/FINDINGS.md keeps that history, including
the Fakespot bias against pre-1920 prose that led to it.
Configuration
SlopTotal detects CPU, RAM and GPU at startup and picks a profile. Everything
can be overridden with environment variables; see .env.example.
| Profile | When chosen (RAM) | CPU | GPU | Notes |
|---|
| Lite | below 8 GB | 2 cores | None | Fewer workers; still loads every model |
| Standard | 8 GB or more | 4 cores | None | Default for most laptops |
| Performance | 16 GB or more | 6+ cores | CUDA optional | Pool replicas, max throughput |
Profiles change workers and replicas, not which engines run. Every profile loads
all models: about 8.3 GB of RAM once loaded (an estimate) and about 9 GB on
disk. Per-engine memory and latency, measured on one machine, are in
docs/MODELS.md.
NVIDIA GPU: requirements.txt installs the CPU-only torch wheel. To run the
models on the GPU, replace it with a CUDA build of the same torch version (keep
the version: upgrading torch can move scores):
pip uninstall -y torch
pip install torch==<installed version> --index-url https://download.pytorch.org/whl/cu130 --extra-index-url https://pypi.org/simple
python -c "import torch; print(torch.cuda.is_available())" # True
cu130 needs an NVIDIA driver with CUDA 13 support and covers RTX 20xx through
50xx; pick another index from pytorch.org
for older cards. With CUDA and at least 4 GB of VRAM, startup selects the
performance profile and the banner shows Device: cuda. All models run in
fp32, so scores match the CPU to three decimals.
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
| Variable | Default | Purpose |
|---|
SLOPTOTAL_PROFILE | auto | lite, standard or performance |
SLOPTOTAL_RETENTION_DAYS | 30 | Delete reports after N days (0 keeps them) |
SLOPTOTAL_DIRECT_DAILY_LIMIT | 0 (no limit) | Calls per client IP per UTC day that start an analysis from outside the first-party origins below; for a public instance |
SLOPTOTAL_FIRST_PARTY_ORIGINS | sloptotal.com, the extension, localhost | Regex of browser origins allowed by CORS and not counted by the daily limit |
SLOPTOTAL_ALLOW_PRIVATE_URLS | off | Let URL scans reach private or intranet hosts (blocked by default) |
SLOPTOTAL_DATA_DIR | project-root data/ | Directory for stored reports and the database |
SLOPTOTAL_DB_NAME | sloptotal.db | Database filename inside the data directory |
SLOPTOTAL_DB_TIMEOUT | 30.0 seconds | SQLite connection timeout |
SLOPTOTAL_DB_BUSY_TIMEOUT | 5000 milliseconds | SQLite busy timeout |
SLOPTOTAL_CACHE_ENABLED | true | Enable result caching (true, 1 or yes, case-insensitive) |
SLOPTOTAL_DEVICE | auto-detected | Override inference device with cpu or cuda; otherwise CUDA is used when available |
SLOPTOTAL_RESERVED_CORES | 2 | CPU cores reserved when calculating usable analyzer cores |
SLOPTOTAL_SHORT_LANE_WORDS | 350 | Word-count threshold for the short-text lane |
SLOPTOTAL_SHORT_WORKERS | 4 | Short-text worker count |
|
Startup profiles populate unset settings before the analyzer reads its fallback
defaults. Explicit environment values take precedence. The lite profile sets
the snippet concurrency limit to 2; other profiles use 4. On CPU, the
performance profile sets all four classifier pools above to 2 when RAM is at least
32 GB; otherwise these pools use 1, including CUDA profiles.
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
| Symptom | Fix |
|---|
TypeError: unsupported operand type(s) for | at startup | Python 3.9 or older; use 3.10+ |
An engine reports Model loading failed | Check disk space and network for the first model download, then restart; python scripts/smoke_test.py shows which engine fails |
| First scan is slow | Models are loading; later scans take seconds |
| A URL scan says "private network address" | Intended; set SLOPTOTAL_ALLOW_PRIVATE_URLS=1 to scan intranet pages |
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:
| Model | RAID AUC | Literary bias (lower is better) | Status |
|---|
| Gradient (DeBERTa-v3-large) | 0.998 | 0.033 | Next engine to add |
| Vanguard (ModernBERT-large) | 0.998 | 0.037 | Candidate; poorly calibrated at 0.5 |
| Earlybird-fast (82M) | 0.913 | 0.040 | Candidate for fast snippet scans |
| rasbt ModernBERT | 0.864 | 0.000 | Not added |
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
Contributing
Contributions are welcome, especially new engines with measurements. Start with
CONTRIBUTING.md.
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.
