Perplexity and Burstiness Explained: Which AI Detectors Use Them

Perplexity is a measure of word predictability. When a language model reads a sentence, it assigns a probability to each word based on the words that came before it. If the next word is highly predictable, the perplexity for that word is low. If the next word is unexpected, the perplexity is high. A full text's perplexity is essentially the average of how predictable the word choices were throughout.

Think of it this way. If you write "The experiment showed a significant," the next word is very likely to be "result" or "difference" or "effect." Those are high-probability words. If instead the next word is "pineapple," that is low-probability, and the perplexity for that position would spike. Text that consistently picks the most expected word has low overall perplexity. Text that makes unexpected choices has higher perplexity.

AI-generated text tends to have low perplexity because language models are designed to pick the most probable next word. They optimize for contextual probability, which means their word choices fall into predictable patterns. Human writing, by contrast, often includes less predictable word choices, unusual verbs, domain-specific nouns, or phrasings that a language model would not have selected. This difference is real and measurable. The question is whether every AI detector uses perplexity as part of its actual algorithm, and the answer is no.

Burstiness is a measure of variation in sentence structure. If every sentence in a paragraph has roughly the same length, the same grammatical structure, and the same rhythm, the burstiness is low. If sentences vary widely, some short and punchy, others long and complex with subordinate clauses, the burstiness is high.

Human writing tends to have higher burstiness than AI-generated text. We write in bursts. We mix a short declarative sentence with a longer one that includes a parenthetical aside. We break pattern when we want to emphasize a point. AI models tend to produce more uniform sentence structures because they optimize for statistical consistency. The result is text that reads smoothly but has less structural variation.

Burstiness was popularized as a detection metric because it captures something real about how human and AI writing differ. Humans are irregular. AI models are consistent. A detector that measures burstiness is looking at whether your sentence-level structure varies enough to look human. Like perplexity, burstiness is a useful concept. Also like perplexity, it is not a metric that every detector computes.

GPTZero is the most prominent example of a detector that publicly uses perplexity and burstiness as named metrics. Their documentation describes perplexity as a measure of how unpredictable text is, and burstiness as a measure of sentence-level variation. The GPTZero algorithm computes these metrics and uses them in its classification decision. If you are trying to understand or optimize for GPTZero's behavior, perplexity and burstiness are directly relevant.

Turnitin takes a different approach. Their official FAQ states: "Our model is not explicitly programmed to evaluate specific signals such as 'burstiness,' 'perplexity,' or other individual metrics sometimes referenced in public discussions." The next sentence says: "Instead, it learns statistical patterns from our training data." This is a direct, explicit denial that Turnitin computes these two metrics.

The reason this distinction matters is that the two tools will sometimes classify the same text differently. A piece of writing engineered to have high burstiness and high perplexity might score differently on GPTZero (where those metrics are directly part of the algorithm) than on Turnitin (where the classifier learned patterns from training data without computing either metric). Advice that says "increase your burstiness" or "lower your perplexity" is calibrated for a specific kind of detector. It may or may not help you with Turnitin.

If Turnitin is not computing perplexity and burstiness, what does it use? The documentation describes a classifier that learns statistical patterns from training data, then applies them to segments of your text.

Turnitin states: "Our model is not explicitly programmed to evaluate specific signals such as 'burstiness,' 'perplexity,' or other individual metrics sometimes referenced in public discussions. Instead, it learns statistical patterns from our training data." The classifier does not run a perplexity formula or a burstiness formula. It applies patterns internalized during training, patterns that involve word probability but are not reducible to a single named score.

The same FAQ page confirms what the classifier does focus on: "Our classifiers are trained to detect these differences in word probability and are adept at the particular word probability sequences of human writers." Word probability is central to what Turnitin's classifier learned, but the model processes it through learned patterns, not an explicit perplexity computation.

The mechanism is segment-based. Turnitin describes it: "When a paper is submitted to Turnitin, sentences from the submission are extracted and segmented into overlapping sections for prediction analysis. Each segment is classified by the AI detection model and given a value between 0 and 1, denoting the probability of the text being likely human or AI-generated." Segments overlap, sentences inherit scores, multiple scores are pooled, and the final aggregation produces the document-level percentage. This pipeline does not include a step where perplexity or burstiness is calculated.

Turnitin also notes: "As a result, its outputs are generated by many learned patterns working together rather than by a small set of transparent, human-readable rules. For that reason, individual predictions may not always be explainable in simple feature-by-feature terms." The model's decision process is not something you can reverse-engineer by tracking a handful of metrics.

The practical takeaway is straightforward. If you read advice that says "lower your perplexity to beat Turnitin," that advice is based on a misunderstanding of the tool. Turnitin does not compute perplexity. Tips about burstiness and perplexity may be relevant for GPTZero, but they do not map onto Turnitin's mechanism.

The issue is that Turnitin's classifier does not use these concepts as named metrics. It learned statistical patterns from training data, patterns that include word probability information, and applies them to your text. You cannot optimize for a metric the classifier does not compute. What you can do is write in ways that reflect genuine human authorship, with natural variation in word choice and structure that differs from the patterns AI models produce.

We offer free re-runs so you can test your writing and see where it stands. Try it here.