Skip to content
Back to search

sloptotal

Open-source AI text detector and ChatGPT detector: 23 engines, one calibrated score, every number measured. CLI, MCP server and GitHub Action. Self-hosted, runs on CPU.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pablocaeg--sloptotal/badge.svg)](/listings/pablocaeg--sloptotal)

HTML

<a href="/listings/pablocaeg--sloptotal"><img src="/api/listings/pablocaeg--sloptotal/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

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

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 443 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <a href="https://sloptotal.com"><img src="docs/assets/banner.jpg" alt="SlopTotal: open-source AI text detector that runs 23 detection engines on your own hardware" width="100%"></a>
  3. </p>
  4. <p align="center">
  5. <a href="https://github.com/pablocaeg/sloptotal/actions/workflows/ci.yml?query=branch%3Amaster"><img src="https://img.shields.io/github/actions/workflow/status/pablocaeg/sloptotal/ci.yml?branch=master&event=push&label=CI" alt="CI status"></a>
  6. <a href="https://github.com/pablocaeg/sloptotal/releases"><img src="https://img.shields.io/github/v/release/pablocaeg/sloptotal?color=b5282e" alt="Latest release"></a>
  7. <a href="https://github.com/pablocaeg/sloptotal/pkgs/container/sloptotal"><img src="https://img.shields.io/badge/docker-ghcr.io-1a1a18?logo=docker&logoColor=white" alt="Docker image"></a>
  8. <img src="https://img.shields.io/badge/python-3.10%2B-3d3b37" alt="Python 3.10+">
  9. <a href="https://github.com/pablocaeg/sloptotal/stargazers"><img src="https://img.shields.io/github/stars/pablocaeg/sloptotal?style=flat&color=e3b341&logo=github" alt="GitHub stars"></a>
  10. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-2d8a4e" alt="MIT license"></a>
  11. <a href="https://sloptotal.com"><img src="https://img.shields.io/badge/live%20demo-sloptotal.com-b5282e" alt="Live demo"></a>
  12. </p>
  13. <p align="center"><b>English</b> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ru.md">Русский</a> · <a href="README.es.md">Español</a></p>
  14. # SlopTotal
  15. **VirusTotal for AI-generated text.** Paste text, drop in a PDF or Word file, or
  16. give it a URL. Twenty-three independent AI detectors (neural classifiers,
  17. statistical tests and linguistic heuristics) score it in parallel, and a
  18. calibrated ensemble turns their votes into one verdict you can inspect engine by
  19. engine. It runs on your own CPU, so nothing you scan leaves your machine.
  20. It is a free, self-hosted, open-source alternative to hosted AI content
  21. detectors such as GPTZero, Originality.ai, Copyleaks, ZeroGPT and Humalingo.
  22. Instead of one number from one model, it shows you every model's opinion, and
  23. it publishes how accurate that is, failures included.
  24. <p align="center">
  25. <img src="docs/assets/demo.gif" alt="Trying the sample text on sloptotal.com: the calibrated score, the verdict band and every engine’s vote" width="820">
  26. </p>
  27. **Try it:** [sloptotal.com](https://sloptotal.com) · **Run it:** `docker run -p 8000:8000 ghcr.io/pablocaeg/sloptotal`
  28. ## Features
  29. - **23 detection engines, one calibrated score.** DeBERTa and RoBERTa
  30. classifiers, Binoculars, Fast-DetectGPT, GLTR, perplexity and burstiness
  31. tests, and stock-phrase heuristics. Results stream in as each engine finishes.
  32. - **Text, URLs and documents.** Paste text, scan a web page (main content is
  33. extracted automatically), or upload `.pdf`, `.docx`, `.txt` or `.md`.
  34. - **Site check: was this website vibe-coded?** Finds the fingerprints that
  35. Lovable, v0, Bolt, Base44, Replit, Same and Emergent leave in the sites they deploy,
  36. and shows the evidence for each one. [How it works](#site-check-detect-sites-built-with-ai-app-builders)
  37. - **Per-paragraph heat map** through the API, to see which parts read as AI.
  38. - **Measured, not claimed.** Every accuracy number below comes with the corpus,
  39. the harness and the raw per-sample scores.
  40. - **Private by default.** Self-hosted, no third-party AI APIs, no tracking,
  41. reports deleted after 30 days.
  42. - **CPU-only is fine.** Auto-detects your hardware; a GPU is optional. Loaded
  43. models need about 8.3 GB of RAM (an estimate; see
  44. [docs/MODELS.md](docs/MODELS.md)).
  45. - **JSON API and a [Chrome extension](https://github.com/pablocaeg/sloptotal-extension)**
  46. that marks AI-looking results in Google Search and LinkedIn.
  47. ## Measured accuracy
  48. Most detectors publish an accuracy figure without saying what it was measured
  49. on. SlopTotal is measured on [SlopBench](tests/eval/slopbench/): 1,626 human
  50. texts, every one written before ChatGPT, and 1,626 AI texts on the same topics
  51. and at the same lengths from 14 current models, across 15 kinds of writing
  52. (news, Wikipedia, arXiv, Stack Exchange, Reddit, reviews, student essays,
  53. non-native English, fiction and literature published 1532-1915). Every number
  54. below is measured on kinds of writing the model was not tuned on.
  55. | | |
  56. |---|---|
  57. | AUC | **0.942** |
  58. | AI texts called "Likely AI" (55+) | 67% |
  59. | Human texts called "Likely AI" (55+) | **1.7%** |
  60. | Human texts flagged at all (45+) | 3.9% |
  61. | Literature published 1532-1915 flagged | **0 of 87** |
  62. The score bands are anchored on that human text: 45 is where the top 5% of
  63. human writing begins, 55 the top 2%, 80 the top 0.5%. So "Likely AI" means
  64. fewer than 2 in 100 human texts score this high.
  65. **Other languages.** Spanish, French, German, Italian, Portuguese, Dutch,
  66. Polish, Russian and Japanese are supported (AUC 0.91 to 0.997); Arabic and
  67. Korean are experimental; Hindi, Turkish and Chinese are not reliable yet, and
  68. the report says so.
  69. **What does not work.** Essays by non-native English writers are still flagged
  70. more than native ones (15% of TOEFL essays called Likely AI, against none of 88
  71. US school essays). Under about 80 words a score is a weak signal. AI text run
  72. through a "humanizer" is caught about half the time. Source code is outside
  73. what these engines do. All of it, per source, per model and per engine, is in
  74. [the findings](tests/eval/slopbench/FINDINGS.md), including that the
  75. classifiers which top the RAID benchmark drop to AUC 0.75 on current models.
  76. ## Quick start
  77. ### Docker (fastest)
  78. ```bash
  79. docker run -p 8000:8000 -v sloptotal-models:/app/models ghcr.io/pablocaeg/sloptotal
  80. ```
  81. Open <http://localhost:8000>. The first scan downloads about 9 GB of models
  82. (see [docs/MODELS.md](docs/MODELS.md)) into the `sloptotal-models` volume, so
  83. later starts are quick. To build from source instead, run
  84. `docker compose -f docker/docker-compose.yml up`.
  85. ### From source
  86. Requires **Python 3.10+** (macOS ships 3.9, which is too old).
  87. ```bash
  88. git clone https://github.com/pablocaeg/sloptotal.git
  89. cd sloptotal
  90. python3.11 -m venv venv && source venv/bin/activate
  91. pip install -r requirements.txt
  92. ./scripts/start.sh # or: uvicorn app.main:app --port 8000
  93. ```
  94. Check that every engine loads and scores, end to end:
  95. ```bash
  96. python scripts/smoke_test.py # against http://localhost:8000
  97. ```
  98. ## Site check: detect sites built with AI app builders
  99. <p align="center">
  100. <img src="docs/assets/site-check.jpg" alt="SlopTotal’s website builder check identifying a site built with Lovable from its hosting, badge and scripts" width="760">
  101. </p>
  102. "Is this website vibe-coded?" checkers mostly score style (Tailwind class
  103. counts, missing security headers, buzzwords) and turn it into a percentage.
  104. Hand-written sites share all of those traits. SlopTotal looks only for markers
  105. the builders themselves leave in what they deploy, each one confirmed on live
  106. sites or in the builders' own templates:
  107. | Builder | Fingerprints |
  108. |---|---|
  109. | Lovable | `gptengineer.js` runtime, `/lovable-uploads/` assets, the Lovable badge, `/~flock.js`, `*.lovable.app` |
  110. | v0 (Vercel) | `<meta name="generator" content="v0.app">` from v0's layout template, `*.vusercontent.net` |
  111. | Bolt | `X-Powered-By: Bolt.new` header, `bolt.new/badge.js`, `*.bolt.host` |
  112. | Base44 | `app.base44.com` platform calls, `base44_access_token`, `*.base44.app` |
  113. | Replit | Replit Agent dev banner, Replit badge, `*.replit.app` |
  114. | Same | assets served from `same-assets.com` |
  115. | Emergent | `__emg_sid` and `__emg_vid` cookies, `emergent-main.js` script, `*.emergent.host` |
  116. A site with no marker may still have been written with AI: code exported from
  117. these tools and hosted elsewhere, or written in an AI editor, carries no
  118. fingerprint. So the result is evidence, not a probability. The page's copy is
  119. scored separately by the text engines.
  120. ```bash
  121. curl -X POST http://localhost:8000/api/scan/site \
  122. -H "Content-Type: application/json" -d '{"url": "example.com"}'
  123. ```
  124. ## API
  125. | Endpoint | Method | What it does | Typical latency (CPU) |
  126. |---|---|---|---|
  127. | `/api/analyze` | POST | Full 23-engine report for `text` or `url` | 2-8 s |
  128. | `/api/quick-score` | POST | 4 classifiers plus heuristics | 0.1-0.5 s |
  129. | `/api/paragraph-score` | POST | Score per paragraph (heat map) | 1-3 s |
  130. | `/api/scan/site` | POST | AI app builder fingerprints plus a copy score | 1-3 s |
  131. | `/api/extract` | POST | Text from an uploaded `.pdf` / `.docx` / `.txt` (multipart `file`) | < 1 s |
  132. | `/api/scan/snippets` | POST | Batch of 1-30 short snippets | ~0.5 s |
  133. | `/api/scan/urls` | POST | Batch of 1-10 URLs, page-type aware | 1-5 s |
  134. | `/api/engines` | GET | Engine metadata | instant |
  135. | `/api/report/{id}` | GET | A stored report | instant |
  136. | `/api/report/{id}/feedback` | POST | Record who actually wrote the text: `{"label": "human" \| "ai" \| "mixed" \| "unsure"}` | instant |
  137. | `/api/queue/status` | GET | Queue capacity | instant |
  138. ```bash
  139. curl -X POST http://localhost:8000/api/analyze \
  140. -H "Content-Type: application/json" \
  141. -d '{"text": "Your text to analyze here..."}'
  142. ```
  143. From Python, [`examples/python_client.py`](examples/python_client.py) analyses a
  144. text, prints the five engines scoring highest and runs a site check, waiting
  145. in the queue when the server is busy:
  146. ```bash
  147. python examples/python_client.py "Paste at least 50 characters of text here..." example.com
  148. ```
  149. The response lists every engine with its score, verdict and a plain-language
  150. detail line, plus `overall_score` (0-100) and `overall_verdict`.
  151. From Node 18+, [`examples/node_client.mjs`](examples/node_client.mjs) uses the
  152. built-in `fetch` to analyse a text and print the overall score, the verdict and
  153. the five engines scoring highest. Pass `--base` to point it at another server:
  154. ```bash
  155. node examples/node_client.mjs "Paste at least 50 characters of text here..." --base http://localhost:8000
  156. ```
  157. ## Detection Engines
  158. 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.
  159. ### Neural Classifiers
  160. | Engine | Model | AUC | Notes |
  161. |---|---|---|---|
  162. | [Desklib DeBERTa](https://sloptotal.com/engines/desklib-deberta/) | DeBERTa-v3-large (435M) | 1.000 | Strongest separation in our own tests |
  163. | [SuperAnnotate](https://sloptotal.com/engines/superannotate/) | RoBERTa-large (355M) | 0.989 | No measurable bias against archaic prose |
  164. | [E5-Small](https://sloptotal.com/engines/e5-small/) | E5 + LoRA (33M) | 0.999 | Matches far larger models at 33M params |
  165. | [TMR Detector](https://sloptotal.com/engines/tmr-detector/) | RoBERTa-base (125M) | 1.000 | RAID-trained, so RAID scores flatter it |
  166. | [BERT-tiny RAID](https://sloptotal.com/engines/bert-tiny-raid/) | BERT-tiny (4.4M) | 1.000 | Answers in milliseconds |
  167. | [ReMoDetect](https://sloptotal.com/engines/remodetect/) | DeBERTa (184M) | 0.941 | Targets RLHF-aligned LLMs |
  168. | [ChatGPT Detector](https://sloptotal.com/engines/chatgpt-detector/) | RoBERTa-base (125M) | 0.829 | ChatGPT-specific |
  169. | [Fakespot](https://sloptotal.com/engines/fakespot/) | RoBERTa-base (125M) | 0.999 | Accurate on modern text, but +0.533 bias on pre-1920 prose |
  170. | [OpenAI Detector](https://sloptotal.com/engines/openai-detector/) | RoBERTa-base (125M) | 0.771 | The 2019 GPT-2 detector; weaker on modern LLMs |
  171. ### Statistical Methods
  172. | Engine | Method | AUC |
  173. |---|---|---|
  174. | [Log-Rank](https://sloptotal.com/engines/log-rank/) | Average log-rank under GPT-2 | 0.909 |
  175. | [GLTR](https://sloptotal.com/engines/gltr/) | Token rank distribution | 0.904 |
  176. | [Perplexity](https://sloptotal.com/engines/perplexity/) | GPT-2 perplexity scoring | 0.901 |
  177. | [Cross-Perplexity](https://sloptotal.com/engines/cross-perplexity/) | Two-model perplexity comparison | 0.891 |
  178. | [Fast-DetectGPT](https://sloptotal.com/engines/fast-detectgpt/) | Conditional probability curvature | 0.890 |
  179. | [Binoculars](https://sloptotal.com/engines/binoculars/) | Cross-entropy ratio between two LMs | 0.836 |
  180. | [DivEye](https://sloptotal.com/engines/diveye/) | Surprisal diversity | 0.730 |
  181. ### Linguistic Heuristics
  182. | Engine | Signal | AUC |
  183. |---|---|---|
  184. | [Structural Analysis](https://sloptotal.com/engines/structural-analysis/) | Em-dash usage, sentence uniformity | 0.836 |
  185. | [Linguistic Markers](https://sloptotal.com/engines/linguistic-markers/) | AI-preferred phrases ("delve", "tapestry"...) | 0.713 |
  186. | [Formulaic Patterns](https://sloptotal.com/engines/formulaic-patterns/) | Cliche openings and closings | 0.698 |
  187. | [Vocabulary Richness](https://sloptotal.com/engines/vocabulary-richness/) | Type-token ratio, hapax legomena | 0.583 |
  188. | [Readability Uniformity](https://sloptotal.com/engines/readability-uniformity/) | Cross-paragraph consistency | 0.581 |
  189. | [Burstiness](https://sloptotal.com/engines/burstiness/) | Per-sentence perplexity variance | 0.582 |
  190. | [Sentiment & Hedging](https://sloptotal.com/engines/sentiment-and-hedging/) | Hedging and forced balance | 0.522 |
  191. 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.
  192. ## Scoring
  193. The overall score is a logistic model over the engine scores, fitted on
  194. [SlopBench](tests/eval/slopbench/). The fitted parameters are in
  195. [app/calibration.json](app/calibration.json), and every number in the fit's
  196. report, [tests/eval/slopbench/FINDINGS.md](tests/eval/slopbench/FINDINGS.md), is
  197. measured on kinds of writing the fit never saw. [docs/CALIBRATION.md](docs/CALIBRATION.md)
  198. explains each field in the JSON and how to regenerate it.
  199. 1. **Weights from a fit, not by hand.** Each engine's score is turned into
  200. log-odds and weighted by the model, with weights kept non-negative. An engine
  201. earns weight only for what it adds once the others are known, so engines that
  202. fail together do not count twice. In English, 8 of the 23 engines carry
  203. weight (Structural, Desklib, Fakespot, SuperAnnotate, Formulaic, Readability,
  204. Binoculars and Burstiness). The other 15 add nothing on top of them, and every
  205. one is still shown in the report.
  206. 2. **Bands set on human text.** The output is mapped so that 45 is where the top
  207. 5% of human texts begin, 55 the top 2% and 80 the top 0.5%.
  208. 3. **Short texts held back.** Short English texts are pulled toward a neutral
  209. score by `words / (words + 5)`; other languages use a fitted short-text term.
  210. Scripts written without spaces (Chinese, Japanese, Thai and others) skip it.
  211. 4. **Other languages.** A separate fit with a per-language offset, placed so 5%
  212. of human text scores above 45, and a support status: supported for German,
  213. Spanish, French, Italian, Japanese, Dutch, Polish, Portuguese and Russian;
  214. experimental for Arabic and Korean; not yet reliable for Hindi, Turkish and
  215. Chinese.
  216. 5. **Confidence from the score.** Low under 80 words, in a language that is not
  217. yet reliable, or between 35 and 65; medium in an experimental language or
  218. between 15 and 80; high otherwise.
  219. Up to v1.1 the score was a hand-weighted blend anchored on four classifiers.
  220. [tests/eval/FINDINGS.md](tests/eval/FINDINGS.md) keeps that history, including
  221. the Fakespot bias against pre-1920 prose that led to it.
  222. ## Configuration
  223. SlopTotal detects CPU, RAM and GPU at startup and picks a profile. Everything
  224. can be overridden with environment variables; see [`.env.example`](.env.example).
  225. | Profile | When chosen (RAM) | CPU | GPU | Notes |
  226. |---------|-------------------|-----|-----|-------|
  227. | Lite | below 8 GB | 2 cores | None | Fewer workers; still loads every model |
  228. | Standard | 8 GB or more | 4 cores | None | Default for most laptops |
  229. | Performance | 16 GB or more | 6+ cores | CUDA optional | Pool replicas, max throughput |
  230. Profiles change workers and replicas, not which engines run. Every profile loads
  231. all models: about 8.3 GB of RAM once loaded (an estimate) and about 9 GB on
  232. disk. Per-engine memory and latency, measured on one machine, are in
  233. [docs/MODELS.md](docs/MODELS.md).
  234. **NVIDIA GPU:** `requirements.txt` installs the CPU-only torch wheel. To run the
  235. models on the GPU, replace it with a CUDA build of the same torch version (keep
  236. the version: upgrading torch can move scores):
  237. ```bash
  238. pip uninstall -y torch
  239. pip install torch==<installed version> --index-url https://download.pytorch.org/whl/cu130 --extra-index-url https://pypi.org/simple
  240. python -c "import torch; print(torch.cuda.is_available())" # True
  241. ```
  242. `cu130` needs an NVIDIA driver with CUDA 13 support and covers RTX 20xx through
  243. 50xx; pick another index from [pytorch.org](https://pytorch.org/get-started/locally/)
  244. for older cards. With CUDA and at least 4 GB of VRAM, startup selects the
  245. `performance` profile and the banner shows `Device: cuda`. All models run in
  246. fp32, so scores match the CPU to three decimals.
  247. **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:
  248. ```bash
  249. # Tune for a 64 GB CPU-only server
  250. export SLOPTOTAL_PROFILE=performance
  251. export SLOPTOTAL_TORCH_THREADS=8
  252. export SLOPTOTAL_FULL_WORKERS=8
  253. export SLOPTOTAL_SNIPPET_WORKERS=6
  254. export SLOPTOTAL_MAX_CONCURRENT_FULL=4
  255. export SLOPTOTAL_POOL_FAKESPOT=2
  256. export SLOPTOTAL_POOL_TMR=2
  257. ./scripts/start.sh
  258. ```
  259. | Variable | Default | Purpose |
  260. |---|---|---|
  261. | `SLOPTOTAL_PROFILE` | auto | `lite`, `standard` or `performance` |
  262. | `SLOPTOTAL_RETENTION_DAYS` | `30` | Delete reports after N days (`0` keeps them) |
  263. | `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 |
  264. | `SLOPTOTAL_FIRST_PARTY_ORIGINS` | sloptotal.com, the extension, localhost | Regex of browser origins allowed by CORS and not counted by the daily limit |
  265. | `SLOPTOTAL_ALLOW_PRIVATE_URLS` | off | Let URL scans reach private or intranet hosts (blocked by default) |
  266. | `SLOPTOTAL_DATA_DIR` | project-root `data/` | Directory for stored reports and the database |
  267. | `SLOPTOTAL_DB_NAME` | `sloptotal.db` | Database filename inside the data directory |
  268. | `SLOPTOTAL_DB_TIMEOUT` | `30.0` seconds | SQLite connection timeout |
  269. | `SLOPTOTAL_DB_BUSY_TIMEOUT` | `5000` milliseconds | SQLite busy timeout |
  270. | `SLOPTOTAL_CACHE_ENABLED` | `true` | Enable result caching (`true`, `1` or `yes`, case-insensitive) |
  271. | `SLOPTOTAL_DEVICE` | auto-detected | Override inference device with `cpu` or `cuda`; otherwise CUDA is used when available |
  272. | `SLOPTOTAL_RESERVED_CORES` | `2` | CPU cores reserved when calculating usable analyzer cores |
  273. | `SLOPTOTAL_SHORT_LANE_WORDS` | `350` | Word-count threshold for the short-text lane |
  274. | `SLOPTOTAL_SHORT_WORKERS` | `4` | Short-text worker count |
  275. | `SLOPTOTAL_MAX_CONCURRENT_SHORT` | `2` | Concurrent short-text scan limit enforced by the queue manager |
  276. | `SLOPTOTAL_MAX_CONCURRENT_SNIPPET` | `4` (`2` in lite) | Concurrent snippet scan limit |
  277. | `SLOPTOTAL_POOL_BERT_RAID` | `1` (see below) | BERT RAID model pool replicas |
  278. | `SLOPTOTAL_POOL_E5` | `1` (see below) | E5 model pool replicas |
  279. | `SLOPTOTAL_POOL_FAKESPOT` | `1` (see below) | Fakespot model pool replicas |
  280. | `SLOPTOTAL_POOL_TMR` | `1` (see below) | TMR model pool replicas |
  281. | `HF_HOME` | `./models` | Where model weights are cached |
  282. Startup profiles populate unset settings before the analyzer reads its fallback
  283. defaults. Explicit environment values take precedence. The lite profile sets
  284. the snippet concurrency limit to `2`; other profiles use `4`. On CPU, the
  285. performance profile sets all four classifier pools above to `2` when RAM is at least
  286. 32 GB; otherwise these pools use `1`, including CUDA profiles.
  287. ## FAQ
  288. **Can AI detectors be trusted?** Not blindly. No detector, this one included,
  289. should be the only evidence for an accusation. That is why SlopTotal shows
  290. all 23 votes, how much they agree, and its measured false-positive rate. Short
  291. text (under about 80 words) and heavily edited AI text are unreliable for every
  292. detector.
  293. **Does it detect ChatGPT, Claude, Gemini, Llama and Mistral?** The evaluation
  294. corpus includes GPT-4, ChatGPT, Llama and Mistral output. The classifiers were
  295. trained on a wider mix. Newer models are covered as far as they share those
  296. fingerprints; the [evaluation harness](tests/eval/) lets you measure any model
  297. you care about.
  298. **Will it flag classic literature or formal writing?** Not in our tests: none
  299. of the 26 passages from Austen, Melville, Kafka, Machiavelli and others is
  300. flagged. Pre-1920 prose is part of the evaluation precisely because naive
  301. detectors fail on it.
  302. **Is my text stored or shared?** It is processed on the server you run. Reports
  303. are kept for 30 days (configurable) so report links work, and nothing is sent
  304. to an outside service.
  305. **Can it detect AI-generated code?** No, and we do not claim it can: in testing
  306. the engines never flagged human code but never caught machine-written code
  307. either. The Site check reports which AI app builder produced a website, which is
  308. a different question.
  309. ## Troubleshooting
  310. | Symptom | Fix |
  311. |---|---|
  312. | `TypeError: unsupported operand type(s) for \|` at startup | Python 3.9 or older; use 3.10+ |
  313. | 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 |
  314. | First scan is slow | Models are loading; later scans take seconds |
  315. | A URL scan says "private network address" | Intended; set `SLOPTOTAL_ALLOW_PRIVATE_URLS=1` to scan intranet pages |
  316. ## Project layout
  317. ```
  318. app/ FastAPI backend: engines, ensemble, site fingerprints, API
  319. web/ The web UI (Jinja2 templates, vanilla JS, no build step)
  320. tests/ Unit tests (seconds, no downloads) and tests/eval/ accuracy harness
  321. scripts/ smoke_test.py (end-to-end) and the model drift check
  322. benchmarks/ Speed and load scripts
  323. ```
  324. [ARCHITECTURE.md](docs/ARCHITECTURE.md) covers the internals. [AGENTS.md](AGENTS.md)
  325. is a short brief for contributors and AI coding assistants.
  326. ## Newer open detectors we measured
  327. Detector models keep appearing on Hugging Face, each with its own accuracy
  328. claim. Before adding any, we score them on the same two corpora. September 2026,
  329. standalone, 180 RAID texts plus the 26 literary passages:
  330. | Model | RAID AUC | Literary bias (lower is better) | Status |
  331. |---|---|---|---|
  332. | [Gradient](https://huggingface.co/ShantanuT01/gradient-ai-text-detector) (DeBERTa-v3-large) | 0.998 | 0.033 | Next engine to add |
  333. | [Vanguard](https://huggingface.co/ShantanuT01/vanguard-ai-text-detector) (ModernBERT-large) | 0.998 | 0.037 | Candidate; poorly calibrated at 0.5 |
  334. | [Earlybird-fast](https://huggingface.co/noumenon-labs/Earlybird-fast) (82M) | 0.913 | 0.040 | Candidate for fast snippet scans |
  335. | [rasbt ModernBERT](https://huggingface.co/rasbt/ai-text-detector-modernbert) | 0.864 | 0.000 | Not added |
  336. RAID-trained models score near 1.0 on RAID by construction and need a different
  337. test set first. The full table, the models we excluded and why, and the raw
  338. scores are in [tests/eval/FINDINGS.md](tests/eval/FINDINGS.md#newer-open-detectors-measured-standalone).
  339. The roadmap is in [TODO.md](docs/TODO.md).
  340. ## Related projects and reading
  341. - [RAID benchmark](https://arxiv.org/abs/2405.07940) (ACL 2024): adversarial AI text detection dataset used in our evaluation
  342. - [Detecting the Machine (2026)](https://arxiv.org/pdf/2603.17522): cross-architecture detector benchmark; ensembles beat single detectors
  343. - [EditLens](https://arxiv.org/abs/2510.03154): human vs AI-edited vs AI-generated classification
  344. - [GLTR](http://gltr.io/): visual token-rank inspection, the inspiration for our GLTR engine
  345. - [distil-labs/distil-ai-slop-detector](https://github.com/distil-labs/distil-ai-slop-detector): a 270M Gemma detector that runs in the browser
  346. - [sloptotal-extension](https://github.com/pablocaeg/sloptotal-extension): the Chrome extension
  347. ## Contributing
  348. Contributions are welcome, especially new engines with measurements. Start with
  349. [CONTRIBUTING.md](.github/CONTRIBUTING.md).
  350. - [Good first issues](https://github.com/pablocaeg/sloptotal/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22): small tasks that name the files to change
  351. - [Report a bug](https://github.com/pablocaeg/sloptotal/issues/new?template=bug_report.yml)
  352. - [Request a feature](https://github.com/pablocaeg/sloptotal/issues/new?template=feature_request.yml)
  353. - [Propose a new engine](https://github.com/pablocaeg/sloptotal/issues/new?template=new_engine.yml)
  354. - [Ask a question or share results](https://github.com/pablocaeg/sloptotal/discussions)
  355. If SlopTotal is useful to you, a star helps other people find it.
  356. ## License
  357. MIT. Model weights keep their own licenses; see
  358. [THIRD_PARTY_LICENSES.md](docs/THIRD_PARTY_LICENSES.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.