AI content detectors work by running a passage through a language model and measuring how predictable, how consistent, and how patterned the wording is, then combining those measurements into a score. Most detectors estimate resemblance to AI-generated text. They don't directly observe who wrote the passage, no matter how confident the number on screen looks.
If you've ever pasted a paragraph into a detector and watched it flag something you wrote yourself, or clear something you know came out of ChatGPT, this is why. The tool isn't reading your intent. It's reading statistical patterns, and those patterns can point the wrong way. This piece is about the mechanism, not how accurate detectors are in practice, which is a separate question with its own evidence.
What an AI detector actually scans
A detector receives text. That's it. Not your browser history, not your drafting process, not any record of who typed what. So the first thing it has to do is turn that text into something it can measure.
A typical pipeline does roughly this: normalize the input, split it into tokens (the word and sub-word pieces a language model reads), break the document into sentences or windows, calculate features at the token, sentence, and document level, pass those features into a classifier or statistical test, aggregate the results, and apply a threshold. Out comes a label, a confidence score, an estimated AI-written percentage, or a set of highlighted spans, depending on the product.
The exact pipeline is proprietary for most commercial tools, so you can't see inside the box. What you can know is that a score from one tool and a score from another aren't measuring the same thing just because they both spit out a percentage. Turnitin, for example, says its AI-writing percentage reflects the overall share of text its model predicts was generated by an AI tool, and that the number doesn't necessarily correlate with the actual amount of text in the submission. Before you trust a number, it helps to know what that number is built to represent.
Perplexity measures how predictable the wording is
Perplexity is the oldest and most talked-about signal in ai detector perplexity burstiness discussions, and it comes straight from how language models work. A language model predicts the next word in a sequence by assigning a probability to every possible next token, based on everything that came before it. Perplexity is a way of scoring how well those predictions matched what was actually written.
If the model kept predicting the actual next word with high confidence, the passage has low perplexity. It was predictable to that model. If the model kept getting surprised, the passage has high perplexity. It's a mathematical inverse of prediction accuracy, so lower perplexity means more predictable text, and higher perplexity means less predictable text.
The logic behind using this as an AI signal is straightforward. A language model generates text by picking tokens from its own probability distribution, so its output tends to land on choices that same model finds unsurprising. A detector can treat consistently low perplexity as evidence the passage resembles machine-generated text.
Here's where it gets messy. A human can write highly predictable prose too, especially in a formal template, a technical field with fixed terminology, or a piece that leans on familiar phrasing. And AI output isn't always low perplexity either, since sampling settings can push a model toward less obvious word choices. There's also no universal number that separates human from AI. Perplexity depends on which model is doing the scoring, since two models can assign completely different probabilities to the same sentence. GPTZero's own support documentation once described a threshold around 85 as a product-specific signal of likely human writing, while stating plainly that there's no absolute perplexity scale. GPTZero has since said it moved away from using perplexity and burstiness as its main detection method after switching to a deep-learning architecture in 2023. A number that mattered in one system's old version may not mean anything in its current one.
Burstiness measures how much that predictability varies
Burstiness gets described informally as variation in sentence length or rhythm, but the more precise version, the one used in how ai detection tools scan text at the technical level, is variation in perplexity across a document. A detector calculates perplexity sentence by sentence or window by window, then checks how much those values swing.
Low burstiness means the predictability stays fairly flat from one sentence to the next. High burstiness means it jumps around, some sentences easy for the model to predict, others much harder. The reasoning is that generated prose can hold a fairly steady level of predictability throughout, while human writing tends to shift more sharply between plain, conventional phrasing and something more specific or syntactically unusual.
Burstiness isn't a measure of creativity or writing quality, and it's not simply counting how varied your sentence lengths are. It's a statistical description of how much the perplexity measurement itself moves around the document. A carefully edited technical report or a formal marketing page can use consistent structure and vocabulary on purpose, which lowers burstiness without any AI involved. And a generated passage can be edited afterward to introduce more variation. As with perplexity, there's no fixed burstiness cutoff. GPTZero's documentation describes it as one input among several, not a standalone verdict.
Token probabilities reveal what the model expected next
Perplexity compresses a lot of information into a single number. Token-level analysis keeps more of the detail, and it's the closest thing to seeing an ai text detection algorithm work in real time.
For each position in the text, a language model can estimate the probability it assigned to the word that was actually chosen there, where that word ranked among all the possible next choices, and how spread out or concentrated the model's uncertainty was at that point. A model's next-token predictions have a high-probability "head," the small handful of words it considers most likely. Generated text often draws heavily from that head, especially under generation settings that favor likely continuations. Human writers range more widely, reaching for words that rank lower on the model's list even when those words are common in everyday language.
The research tool GLTR made this visible back in 2019 by color-coding every token in a passage by its rank in the model's predicted distribution: green for the top 10 most likely choices, yellow for ranks 11 to 100, red for ranks 101 to 1,000, and purple for anything ranked lower than that. A passage heavy on green tokens looks like the output of a process favoring likely continuations. One with more red and purple looks less like that pattern. GLTR's own authors were careful to describe this as evidence for an informed judgment call, not a definitive verdict, and that caution still applies to any tool using the same underlying idea.
This is also where false positives creep in. A human writing in a second language, following a strict template, or working in a narrow technical vocabulary can produce a lot of high-probability tokens without any AI involved. Meanwhile a generated passage can land on lower-ranked tokens because of sampling settings or a human editing pass afterward. Token-level evidence depends heavily on which model is doing the scoring and how the text was generated, so it isn't a fingerprint that holds steady across every AI system.
Two families: learned classifiers and zero-shot tests
Detectors generally fall into a few families, and knowing which one you're looking at changes how much weight to put on its score.
A trained classifier learns from labeled examples, human-written passages on one side, AI-generated passages on the other. It's a machine learning model, often built on a transformer encoder, and it learns to draw a boundary between the two classes based on combinations of features: token probability patterns, word and phrase distributions, sentence structure, repetition, and sometimes deeper semantic representations. The classifier doesn't rely on one hand-picked threshold. It learns the boundary from its training data, which means the boundary reflects whatever models, genres, languages, and writing samples were in that training set. This is a big part of why two detectors can look at the same passage and disagree: different training data, different scoring models, different thresholds.
A zero-shot detector skips the separate training step and instead tests whether a passage behaves the way a particular language model's own output tends to behave. DetectGPT is a well-documented example. It calculates a source model's probability score for the original passage, then generates several lightly reworded versions (masking a few spans and refilling them with a separate model), and calculates the source model's probability score for each of those. If the original passage scores noticeably higher than its nearby rewrites, that's read as a sign the text sits in a spot the source model would naturally produce. This method works best when the model doing the scoring is the same model that generated the text, and its performance can drop when a different model has to stand in as a substitute.
Neither approach observes the act of writing. Both infer origin from statistical behavior, just through different mechanics.
Watermarking AI text: a signal added, not inferred
Everything above infers origin after the fact, reading patterns in text that already exists. Watermarking AI text flips that: it changes how the text gets generated in the first place, embedding a signal a detector can later test for.
One well-documented approach works like this. Before the model picks its next token, a keyed procedure splits the vocabulary into a "green list" and a "red list" based on the preceding tokens. During generation, the model gets a soft nudge toward green-list tokens, especially in spots where it has many plausible choices anyway. This repeats at every token. A detector that knows the scheme can reconstruct the green lists from the finished text and run a statistical test checking whether the passage contains more green tokens than random chance would produce. The bias is designed to be invisible to a human reader. There's no visible tag or special character, just a small statistical lean in which words got picked.
Watermark detection has real limits. It only works if the system that generated the text actually used that specific watermarking scheme in the first place. Ordinary AI-written text from a system that never applied a watermark won't carry the signal, no matter how it was written. The strength of the evidence depends on how much usable text there is and on how many tokens had multiple plausible choices to begin with, since a model with very few options at a given point has less room to lean toward the green list. Heavy editing, paraphrasing, or translation can also strip out the tokens that carried the signal, so watermarking should be considered a strong signal under the right conditions, not an indestructible label.
Why a score can flag human writing as AI
An AI detector measures resemblance to a learned or engineered pattern. It doesn't watch you write. That gap is exactly where false positives come from.
Mechanically, a false positive happens when a human passage shares the statistical traits a detector associates with generated text: consistently predictable word choices, repeated sentence structures, formulaic transitions, low variation in sentence-level perplexity, a narrow technical vocabulary, or prose that's been heavily standardized through editing. None of that requires AI involvement. It just requires writing that happens to sit on the AI-like side of whatever boundary the detector learned.
A false negative works in the other direction: AI-generated text that doesn't resemble the detector's learned pattern closely enough, often because of sampling choices, a human revision pass, paraphrasing, or a source model the detector wasn't tuned to catch. Mixed documents make this harder still. A piece with human writing, generated passages, quoted material, and edits all folded together still gets compressed into one document-level label, which flattens a real mixture into a single number.
The history here is worth knowing. OpenAI released a classifier in January 2023 that correctly identified 26% of AI-written text in its own English test set and incorrectly labeled human writing as AI-written 9% of the time. OpenAI said the tool was very unreliable on passages under 1,000 characters, and it shut the classifier down in July 2023 citing that low accuracy. Those numbers describe one specific tool at one specific point, not a current benchmark for every detector on the market, but they're a useful reminder that a detector's output is a probabilistic signal, not a finding of fact.
With AI detector false positives explained this way, the more accurate description of a flagged passage isn't "the tool knows this is AI." It's closer to: the passage contains statistical properties the detector has learned to associate with AI-generated text. That phrasing keeps the mechanism honest without claiming more than the tool can actually prove. The fix for a flagged draft usually isn't arguing with the score. It's adding original insight the detector's learned pattern doesn't already cover.
What the score is actually telling you
Put the pieces together and a detector score is evidence of resemblance, not proof of authorship. Perplexity tells you how predictable a passage was to one particular model. Burstiness tells you how much that predictability moved around the document. Token rank and entropy tell you where each word sat in the model's expected range. A trained classifier folds several of these signals together into one learned boundary. A watermark, when present, is the one signal that isn't inferred at all: it's a pattern the generating system put there on purpose.
None of these signals observes intent, and none of them can rule a passage in or out with certainty on their own. When you're looking at a score, it's worth asking what kind of detector produced it, what text was actually analyzed, whether the system is inferring authorship from statistical patterns or checking for an embedded watermark, and what the vendor itself says that particular number is meant to represent. A score built on stronger footing, like a confirmed watermark match, carries different weight than a percentage built from perplexity and burstiness alone.
This matters for a practical reason too, well beyond any single detector check. Content that reads as generic and low-perplexity to a machine doesn't just risk a false flag. It's also less likely to sound distinct to the human readers and AI search engines it's actually written for. Writing that reflects specific brand context, real product detail, and a consistent voice tends to avoid the flattened, predictable patterns detectors are built to notice in the first place, not because it's dodging a tool, but because it isn't generic to begin with.
