How AI Detectors Actually Work (and Why They Flag You)

What an AI detector is really measuring

An AI detector does not know who wrote a sentence. It has never seen your document before, and it cannot check it against a hidden database of ChatGPT outputs. Instead, it scores how predictable your text is compared to the patterns large language models tend to produce.

Modern detectors are themselves machine-learning models trained on millions of human and AI passages. They look for the statistical fingerprints that generation leaves behind, then output a probability. Nothing in that pipeline verifies authorship. A detector cannot see your browser history or watch you type; it can only say that your text resembles, or does not resemble, the machine writing it was trained on.

Think of it like a spam filter. It has learned what junk mail usually looks like, so it flags messages that share those traits, but it can never be certain about any single email. AI detection works the same way, which means every score is a hunch dressed up as a number. That also changes how you should read a result: "85% AI" does not mean 85% of your text is machine-written. It means the detector is fairly confident about a guess.

Perplexity: how surprising your words are

Perplexity is the single most important signal. It measures how surprised a language model is by each word you chose. If every next word is exactly what the model would have predicted, perplexity is low, and the text looks machine-written. Humans are less predictable: we reach for an odd adjective, break a rule, or phrase something in a slightly awkward way, and each of those choices pushes perplexity up.

A concrete pair makes this visible. Sentence one: "Regular exercise is important because it improves both physical and mental health." Sentence two: "I keep exercising because my knees complain less and my inbox feels less terrifying afterward." Both are grammatical and both make the same basic point, but the first is assembled entirely from words a language model would rank as the most likely next choice; "regular exercise is important because" is practically a template. The second takes small risks: knees that complain, an inbox that terrifies. A model scoring word-by-word probability finds the first sentence unsurprising and the second genuinely hard to predict, so the first reads as AI and the second reads as human.

This is also why polished, generic writing gets flagged even when a person wrote every word. Perplexity does not measure effort or honesty, only predictability, and some perfectly human writing is very predictable.

Burstiness: the rhythm of real writing

Burstiness measures variation in sentence structure and length. People write in bursts: a long, winding sentence followed by a short one. Three words. Then a complex clause packed with detail that runs on longer than it probably should.

AI output is smoother. Left on its defaults, a model produces sentences that hover around the same length, open with similar constructions, and land with the same even cadence, paragraph after paragraph. Put the two side by side and you can often spot the difference before reading a word: human text looks jagged on the page, machine text looks like brickwork.

Detectors quantify that jaggedness. Low burstiness plus low perplexity is the classic AI signature, and when both are present a detector becomes confident the text was generated, even if the topic and grammar are flawless. Either signal alone is weak, though. A poet writes with wild burstiness and a contract lawyer with almost none, and both are human, which is why serious tools always combine the two.

Token probability under the hood

Language models write one token at a time, and each token comes with a probability score. Detectors approximate these probabilities and check whether your text sits inside the model's "comfort zone" of likely choices. When a passage is built almost entirely from high-probability tokens arranged in an even rhythm, it matches how ChatGPT, Gemini, and Claude generate by default, and the detector converts that pattern into the percentage you see.

This also explains why short snippets are unreliable to test. With only a sentence or two, there is not enough signal to separate a careful human from a model, so scores swing wildly. Most vendors quietly agree: several refuse to score anything under a few hundred words, because below that length the math is closer to a coin flip than a measurement.

Statistical detectors vs classifier-based detectors

Detection tools fall into two families, and knowing which one you are facing explains a lot of odd results. Statistical detectors use a reference language model to compute probabilities directly: they run your text through the model, measure perplexity, burstiness, and related quantities, then apply a threshold. Research methods like GLTR and DetectGPT work this way, and so does the scoring behind many free checkers. Their strength is that they need no labeled training data; their weakness is that the verdict depends heavily on which reference model does the scoring.

Classifier-based detectors are trained instead. The vendor collects large corpora of known human and known AI text, then fine-tunes a model, often a RoBERTa-style transformer, to tell the two apart. Turnitin, Originality.ai, and Copyleaks are built this way. Classifiers pick up subtle cues beyond raw perplexity, so they tend to be more accurate on text that resembles their training data, but they degrade on writing from newer models, other languages, or domains they never saw, and nobody outside the vendor can inspect what they actually learned.

Most commercial products are now hybrids of both approaches, which is one reason their scores are hard to interpret and even harder to compare across tools.

Why ChatGPT, Gemini, and Claude output gets flagged

Frontier models are trained to be clear, safe, and fluent, and the final round of that training rewards answers most reviewers rate as well-written. That pushes output toward balanced sentences, tidy transitions like "moreover" and "in conclusion," and vocabulary that stays in the statistical middle of the road.

Those same qualities are exactly what detectors hunt for. The more polished and "average" the writing, the lower its perplexity and burstiness, and the higher the AI score. Ironically, raw human drafts full of typos and quirks often pass more easily than a clean AI first draft, because the flaws are what carry the human signal.

What GPTZero, Turnitin, ZeroGPT and others actually check

The major tools share the same core logic but tune it differently. GPTZero popularized perplexity and burstiness scoring and reports both at the sentence level. Turnitin AI integrates detection into its plagiarism suite for schools, breaking documents into overlapping segments and flagging the ones its classifier believes are model-written.

ZeroGPT offers a fast, free per-sentence readout, while Originality.ai targets publishers and SEO teams with a strict, confidence-weighted score. Copyleaks emphasizes multi-language coverage and enterprise reporting. All of them are probabilistic, which is why none can honestly claim to be perfect, and why each vendor's accuracy marketing quietly describes tests the vendor designed itself.

Why detectors disagree with each other

Paste the same essay into three detectors and you can get 2% AI from one, 45% from another, and 88% from a third. That spread is not a bug in one of them; it is what happens when different systems make different guesses from the same evidence.

Each tool is trained on its own corpus, scores with its own reference model, chunks text differently (whole document versus sentence by sentence), and sets its own threshold for what counts as "likely AI." A tool calibrated to avoid false accusations will run conservative and under-flag; a tool sold on catching cheaters will run aggressive and over-flag the same text. They also update on different schedules, so a detector tuned before a new model launched will misjudge that model's style for months.

The practical lesson is that no single score is definitive, and disagreement between tools is direct evidence of how much guesswork is involved. If your school checks with Turnitin, only Turnitin's verdict matters, and a clean score elsewhere neither predicts nor protects you from it.

False positives: the published numbers

Because detectors judge predictability, they routinely misfire, and the misses are not hypothetical. OpenAI's own classifier, launched in January 2023, identified only 26% of AI-written text while mislabeling 9% of human text as AI, and the company retired it within six months for low accuracy. Turnitin claims a document-level false positive rate under 1%, but has acknowledged that individual flagged sentences are far less reliable, which is why it withholds scores on documents with only small amounts of suspected AI text.

The most troubling finding involves non-native English speakers. Stanford researchers tested seven popular detectors on essays written by real students for the TOEFL exam and found that, on average, 61% of these human-written essays were flagged as AI-generated, and nearly all of them were flagged by at least one detector. Essays by native-speaking US students sailed through the same tools almost untouched.

The mechanism is exactly what this article describes: writers working in a second language tend to use safer vocabulary and more regular sentence structures, which lowers perplexity, which reads as machine text. The bias is baked into the method itself. This is why responsible schools treat a detector score as the start of a conversation, not as proof. A number is not evidence.

Watermarking: the fix that has not shipped

Researchers have long argued the real solution is watermarking: having the AI model itself embed an invisible statistical signature at generation time. In the best-known scheme, the model secretly favors a rotating "green list" of tokens while writing. A reader cannot notice the pattern, but a detector holding the key can test for it with far better accuracy than perplexity guessing.

It mostly has not shipped. OpenAI built a text watermarker reported internally to be about 99.9% effective on long passages, and has sat on it, citing concerns that paraphrasing or translation strips the mark, that it could stigmatize non-native speakers who legitimately use AI for polish, and, less nobly, that users would simply switch to tools that do not watermark. Google's SynthID-Text is the exception, running inside Gemini and released as open source, but it only marks Gemini's own output.

That is the core problem: a watermark only covers models whose makers cooperate, and open-weight models anyone can run locally will never carry one. So the detector your school or employer uses today is still doing statistics, not reading watermarks, with all the uncertainty that implies.

How detectors handle mixed human and AI text

Real documents are rarely all one thing. A student drafts an intro by hand, asks ChatGPT to expand two body paragraphs, then edits the whole thing. Detectors deal with this by sliding a window across the document, scoring each sentence or segment separately, and highlighting the stretches that look generated.

Mixing weakens every signal. Human edits inside an AI paragraph raise its perplexity; AI sentences inside a human section drag its rhythm toward uniformity. The result is a mid-range score that could mean "half AI" or "all human, oddly written," and the per-sentence highlights are noticeably less reliable than the overall number. Turnitin, for instance, has said its sentence-level flags carry a higher error rate than its document score, and for a while it refused to display low percentages at all because they were so shaky.

In short: the more blended the document, the blurrier the verdict, and highlighted sentences in a report deserve even more skepticism than the headline percentage.

How humanizing lowers the score

If detectors reward high perplexity and burstiness, the fix is to write more like a person: vary sentence length, use less predictable word choices, add natural transitions, and break the uniform rhythm. Doing this by hand across a full document is slow, which is why an AI humanizer exists to rewrite text and restore that human variation automatically.

A tool like Humanize AI rephrases model output so it regains natural burstiness and less predictable phrasing, helping it bypass AI detection while keeping your meaning intact. Crucially, it shows a before-and-after score from real detectors, so you are measuring the change rather than hoping. The goal is not deception but writing that finally sounds like you.

What this means for you in practice

A few habits follow directly from how the technology works. Test before you submit, because guessing at a score is pointless when checking is free; you can run your draft through the free AI humanizer and see the detector numbers before anyone else does. Never trust a verdict on a short passage, and treat sentence-level highlights as weak evidence at best.

If you write honestly, keep your receipts: draft versions, notes, and editing history are far better proof of authorship than any counter-score, especially if you are a non-native speaker writing in the formal register detectors mistrust. And if you are facing a specific checker, learn its specific behavior; Turnitin in particular has quirks worth knowing, which is why we wrote the Turnitin guide as a companion to this one.

Above all, remember what a detector is. It is a pattern-matcher scoring predictability, built by a vendor, tuned to a threshold, and wrong at a measurable rate in both directions. Useful, sometimes. Proof, never.

Frequently asked questions