How AI Detectors Work: The Technology Explained

AI detectors aren't magic. They're statistical classifiers that measure how predictable your writing is, and they rely on a surprisingly small number of signals to make their call. Understanding exactly what these tools measure — and where they break down — is the first step to navigating the AI detection landscape intelligently.

What Is the Core Idea Behind AI Detection?

Every AI detector starts from the same basic insight: language models are trained to predict the most likely next word in a sequence. That means the text they generate is, on average, more predictable than what a human would write. Humans take detours. We use odd phrasing. We start sentences one way and finish them another. Language models smooth all of that out.

AI detectors exploit this predictability gap. They run your text through a model (often a variant of the same architecture that generated the text in the first place) and measure how surprised the model is by each word. If the model isn't surprised very often — if your text is exactly what it would have predicted — the detector flags it as AI-generated.

That's the 30-second version. But the implementation details matter, because different detectors use different approaches, and those differences determine when they work, when they fail, and what kinds of text trip them up.

The Two Statistical Signals: Perplexity and Burstiness

The earliest AI detectors — and many current ones — rely primarily on two metrics: perplexity and burstiness.

Perplexity: How Predictable Is Each Word?

Perplexity measures how “surprised” a language model is by a piece of text. Technically, it's the inverse of the geometric mean of the probability distribution over all possible next words in a sequence. In practical terms: if a model reads “I sat at the bar and ordered a glass of red…” and the next word is “wine,” that's low perplexity. If the next word is “paint,” that's high perplexity.

AI-generated text tends to have low perplexity. This makes intuitive sense: language models are literally optimized to pick the most probable next word (or a word from the top of the probability distribution). The result is fluent, coherent, and predictable prose. Human writing, by contrast, is messier. We make unexpected word choices, use niche vocabulary, insert cultural references, and occasionally write sentences that don't quite parse.

A perplexity score of 1 would mean perfect prediction — the model knew exactly what was coming. Higher scores mean more surprise. Most AI content scores between 10 and 30 on perplexity. Most human writing scores between 40 and 100+, though this varies enormously by domain, style, and the specific model used for measurement.

Burstiness: How Much Does Your Writing Vary?

If perplexity measures word-level predictability, burstiness measures document-level rhythm. It captures the variation in sentence length, structure, and complexity across an entire piece of writing.

Humans write in bursts. A long, rambling sentence followed by a short, punchy one. A paragraph of technical jargon followed by a casual aside. We speed up and slow down based on our emotional state, the complexity of what we're explaining, and whether we just had another cup of coffee.

AI text has low burstiness. Language models produce remarkably uniform sentence lengths — typically clustering between 15 and 25 words per sentence. The variation that does exist is shallow. You won't find a 3-word sentence followed by a 47-word sentence in typical GPT-4 output. That uniformity is one of the clearest statistical fingerprints detectors look for.

Classification Models: The Neural Network Approach

Simple perplexity and burstiness thresholds were enough to catch early ChatGPT output. They're not enough anymore. As language models improved, the statistical gap between human and AI text narrowed, and detectors needed more sophisticated approaches.

Modern AI detectors use transformer-based classification models — neural networks that have been trained on massive datasets of labeled human and AI text. Instead of checking two metrics, these models learn hundreds or thousands of features simultaneously: word frequencies, transition patterns, syntactic structures, punctuation habits, paragraph organization, and more.

The training process works like this: you feed the model millions of examples of confirmed human writing and confirmed AI writing. The model learns the boundary between them — not as a simple threshold on one variable, but as a complex decision surface in a high-dimensional space. When new text comes in, the model outputs a probability: “this text has a 94% chance of being AI-generated.”

This approach is more powerful than perplexity/burstiness alone, but it introduces its own problems. Classification models are only as good as their training data. If the model was trained mostly on GPT-3.5 output, it may struggle with GPT-4o or Claude. If it was trained on English academic essays, it may produce false positives on creative fiction or conversational writing.

How Each Major Detector Works

Not all detectors are built the same. Here's what we know about how the major players approach detection.

GPTZero

Created by Edward Tian at Princeton in 2023, GPTZero was one of the first dedicated AI detectors. Its approach combines sentence-level perplexity analysis with a proprietary deep learning model that evaluates text at both the sentence and document level.

GPTZero measures how predictable each sentence is (perplexity) and how much variation exists across sentences (burstiness), then uses these as input features for a classification model. What makes GPTZero somewhat unique is that its model is trained to handle mixed content — documents where some paragraphs are human-written and others are AI-generated. It assigns per-sentence probabilities, highlighting specific sentences it believes are AI-written rather than just giving a single document-level score.

In independent testing, GPTZero achieves approximately 91% accuracy on unedited AI content, with a false positive rate around 9.2%. It performs best on long-form academic text and worst on short, casual writing.

Turnitin

Turnitin's AI writing detection uses a transformer-based classifier trained specifically on academic writing. The training dataset includes millions of human-written academic papers alongside AI-generated content from GPT-3, GPT-3.5, and GPT-4.

Instead of analyzing a document as a single unit, Turnitin breaks it into segments of roughly 5 to 10 sentences each. Each segment receives its own probability score from 0 to 1. The final document score is an aggregate of these segment scores. This segment-based approach helps Turnitin handle mixed content — a document where a student wrote the introduction but used ChatGPT for the body paragraphs.

Turnitin also added a dedicated paraphrasing detection layer in August 2025, specifically designed to catch text that has been processed through paraphrasing tools like QuillBot. This makes Turnitin harder to bypass with simple rewording.

Originality.ai

Originality.ai targets content marketers and publishers rather than academic institutions. Its detection model is updated frequently to handle output from the latest language models. The company claims to retrain their model within days of a new LLM release.

Originality uses a classification approach similar to Turnitin, but trained on a broader dataset that includes marketing copy, blog posts, and journalistic writing rather than purely academic text. It also provides a combined “AI + plagiarism” score. Independent accuracy estimates range from 76% to 94%, depending on the content type and AI model.

Copyleaks

Copyleaks claims the highest accuracy numbers of any detector: 99.1% detection with under 0.2% false positives, backed by a peer-reviewed study. One independent study found that Copyleaks correctly identified all 126 test documents with zero errors. For a full breakdown, see our Copyleaks AI detector review.

However, Copyleaks' F1 score (which balances precision and recall) dropped below GPTZero and Turnitin in broader testing. Its strength is raw AI text from common models. Its weakness, like every other detector, is paraphrased or humanized content.

ZeroGPT

ZeroGPT uses what it calls “DeepAnalyse Technology,” which is primarily a perplexity-and-burstiness approach. It claims 98% accuracy, but independent testing consistently puts it lower — around 70–85% with a false positive rate of 14.6% to 20.5%.

ZeroGPT's reliance on just two primary signals makes it more susceptible to bypass techniques that target sentence structure and vocabulary variation. It's also the least reliable for non-native English speakers, with false positive rates climbing to approximately 21% for ESL writers.

Watermark Detection: The Third Approach

Beyond statistical analysis and classification models, there's a third detection method that's increasingly relevant: watermark detection.

Text watermarking works at the generation stage, not the detection stage. When a language model generates text, it can embed an invisible signal by subtly biasing which tokens it selects. The most widely studied approach divides the vocabulary into “green” and “red” tokens at each generation step (based on a pseudorandom key derived from preceding tokens) and softly promotes green tokens during sampling. The text reads normally to humans, but a detector with the key can measure the green-token frequency and confirm the watermark.

Google's SynthID-Text is the most production-ready implementation. It modifies only the sampling procedure — no model retraining required — and claims high detection accuracy with minimal impact on text quality or latency. SynthID is deployed on Gemini output.

OpenAI has developed its own watermarking system that reportedly achieves over 99% accuracy in controlled tests. However, OpenAI has been reluctant to deploy it, citing concerns about “stigmatization and user impact.”

The critical limitation of watermarking is that paraphrasing or editing the text degrades the signal. If someone runs watermarked text through a humanizer or even just rewrites a few sentences, the green-token pattern breaks down and the watermark becomes undetectable. This means watermarking can confirm AI origin for unmodified text, but it can't reliably detect AI text that has been edited after generation.

There's also the fragmentation problem: SynthID only works on Google models, OpenAI's watermark only works on OpenAI models, and open-source models like Llama and Mistral don't have watermarks at all. Unless every AI provider adopts a universal watermarking standard — which shows no signs of happening — watermark detection will remain a partial solution at best. For a deeper look at the watermarking landscape, see our explainer on how AI watermarking works.

The Math Behind Detection (Simplified)

To understand why detection is fundamentally hard, you need to understand the statistics at play.

AI detectors are binary classifiers. They sort text into two buckets: human or AI. The performance of any binary classifier is defined by four numbers:

• True positives: AI text correctly identified as AI
• True negatives: Human text correctly identified as human
• False positives: Human text incorrectly flagged as AI
• False negatives: AI text that slips through as human

Here's the uncomfortable tradeoff: reducing false positives necessarily increases false negatives, and vice versa. If a detector tightens its threshold to avoid wrongly accusing humans, it will miss more AI text. If it loosens its threshold to catch more AI text, it will wrongly flag more human writing.

Turnitin made this tradeoff explicitly: they calibrated their detector to maintain a false positive rate under 1%, which means they intentionally allow approximately 15% of AI content to go undetected. They'd rather miss some AI text than accuse an innocent student. Vanderbilt University's analysis showed that even this 1% rate translates to hundreds of wrongly accused students per year at a single institution.

This tradeoff gets worse as AI models improve. The better language models get at producing human-like text, the more the statistical distributions of human and AI writing overlap. As that overlap grows, the boundary between “definitely human” and “definitely AI” gets thinner, and the uncertain middle ground gets larger.

Where Do AI Detectors Reliably Fail?

Understanding what breaks detectors is just as important as understanding how they work. There are consistent, well-documented failure modes.

Non-Native English Speakers

A Stanford study by Liang et al. found that AI detectors misclassified over 61% of TOEFL essays written by non-native English speakers as AI-generated. The reason is structural: non-native speakers tend to use simpler vocabulary, shorter sentences, and more predictable phrasing — exactly the same low-perplexity, low-burstiness patterns that detectors associate with AI. This isn't a bug in one detector. It's a systemic bias in how statistical detection works.

Edited or Mixed Content

When a student uses AI to draft an outline but writes the actual content, or uses AI for one paragraph and writes the rest, detectors struggle. Mixed content creates statistical signals that are neither clearly human nor clearly AI. University of Maryland researchers foundthat AI detectors “are not reliable in practical scenarios” for exactly this reason — and mixed usage is how most people actually interact with AI writing tools.

Formulaic Human Writing

Legal briefs, insurance forms, medical documentation, government reports, and boilerplate business communication all have low perplexity and low burstiness by nature. They're written to be clear and standardized, not creative. Detectors routinely flag this kind of content as AI-generated, even when it was written entirely by humans who are following established templates and conventions.

Short Text

Statistical analysis needs data. With a 50-word passage, there simply aren't enough sentences to measure burstiness or enough words to calculate meaningful perplexity. Most detectors explicitly warn that accuracy drops below 250–300 words, and many refuse to scan text shorter than 100 words. Short answers, email responses, and social media posts are in a statistical dead zone.

Newer Language Models

Every new generation of language models produces text that's harder to detect. GPT-4o, Claude 3.5 Sonnet, and Gemini 2 all produce more varied, less predictable text than their predecessors. Detectors need to be constantly retrained, and there's always a lag between a new model's release and when detectors can reliably identify its output. As discussed in our analysis of the AI detection arms race, this gap is widening, not shrinking.

Why Is AI Detection Fundamentally Flawed?

There's a deeper issue that no amount of engineering can fully solve. AI detectors are trying to distinguish between two text sources that are converging.

Language models are explicitly trained, through reinforcement learning from human feedback (RLHF), to produce text that reads as naturally human as possible. Every improvement in output quality is simultaneously an improvement in detection evasion — even though that's not the goal. The models aren't being trained to evade detection. They're being trained to be good at writing, and good writing is inherently less detectable.

At the theoretical limit, if a language model could perfectly simulate the full distribution of human writing, no statistical test could tell them apart. We're not at that limit yet, but the gap is closing with each model generation.

This is why the detection industry is a treadmill. It can't be “solved” once. Every detector improvement gets countered by the next model improvement, and the fundamental statistics favor the generators in the long run.

What This Means for You

If you understand how detectors work, you can make smarter decisions about your writing.

• No single detector should be trusted as definitive. They disagree with each other regularly, and each has documented blind spots. Check your content with our free AI detector to understand where you stand.
• Perplexity and burstiness are the two signals to watch. If your writing has varied sentence lengths and unpredictable word choices, you're less likely to be flagged — whether you used AI or not.
• Classification models are more accurate but less transparent. When Turnitin or GPTZero gives you a score, you can't easily see why. The decision is based on hundreds of learned features, not a simple checklist.
• Watermarking is coming but isn't universal. If you use Gemini, your text may already be watermarked. If you use open-source models, it's not. This fragmentation will persist.
• The technology is imperfect, and the stakes are real. False accusations based on flawed detectors have led to academic suspensions, lawsuits, and career damage. Know your rights and document your writing process.