DetectGPT vs DNA-GPT vs Fast-DetectGPT: How Three Zero-Shot Methods Compare

Three research papers, three names that sound nearly identical, one shared ancestor. If you’ve run into DetectGPT, DNA-GPT, and Fast-DetectGPT and assumed they were the same thing with different branding, you’re not far off — and also not quite right. They split on a few decisions that matter in practice: how they probe your text, what model access they need, and how long they take to answer.

This isn’t a deep dive into any one method. It’s a map of how the three relate, so the next time one of these names shows up in a paper or a pitch, you know what’s under the hood.

Key takeaways

• All three are zero-shot. They need no labeled training set — just access to a language model’s probability or generation behavior.
• DetectGPT measures probability curvature by rewriting your text around a hundred times and watching the score drop. Accurate, but slow.
• DNA-GPT skips perturbation. It cuts your text in half, lets the model finish it, and measures the overlap. It even has a black-box mode that only needs API output.
• Fast-DetectGPT keeps DetectGPT’s core idea but estimates the curvature in roughly one pass, reporting about a 340x speedup and higher accuracy in its own experiments.
• None of them outputs “AI” or “human.” They all return a probability, and all share the same false-positive risks.

The common ancestor: zero-shot detection

Start with what the three share, because it’s the whole reason they get grouped together.

A normal AI detector is a trained classifier. You feed it thousands of human-written samples and thousands of machine-written ones, it learns the patterns, and then it judges new text. The weakness is built in: when a newer model ships and writes differently, your classifier is grading fresh text with stale habits.

Zero-shot methods refuse to play that game. They never train on labeled examples. Instead, they lean on a language model itself as a measuring stick — asking it how it would score, or how it would continue, a given passage. DetectGPT, DNA-GPT, and Fast-DetectGPT are all zero-shot. That’s the family resemblance. Where they diverge is how they use the model as a ruler.

If the idea of a model assigning probabilities to text is fuzzy, we cover the statistics behind perplexity and burstiness separately. Here we’ll assume a model can score text, and focus on what each method builds on top.

DetectGPT: rewrite it and watch the score fall

DetectGPT, from Eric Mitchell and colleagues at Stanford in 2023, is the original of the bunch. Its insight is about curvature.

When a model writes, it leans toward high-probability words. So machine-written passages tend to sit on a local peak of the model’s probability landscape — a hilltop. Almost any small rewrite walks you downhill, toward lower probability. Human writing doesn’t perch on a peak like that, so nudging it sends the score wandering both up and down.

DetectGPT measures this directly. It scores your original text, then makes dozens of slightly reworded copies — the paper used a second model to mask out short spans and fill them back in — and re-scores each one. If the perturbed versions almost always score lower, your text was on a peak. Machine signature. If the scores scatter, the curvature is flat, which points toward a human.

The catch is cost. The paper approximates the score with about a hundred perturbed copies per passage, which is slow, and the classic form wants the actual probability numbers from the model that wrote the text — a white-box assumption you often can’t satisfy.

DNA-GPT: let the model finish your sentence

DNA-GPT — Divergent N-Gram Analysis, from Yang and colleagues in 2023 — throws out perturbation and asks a different question. Instead of “what happens when I reword this?” it asks “what would the model have written next?”

Here’s the move. DNA-GPT cuts your passage off partway through — say, at the halfway mark — hands that opening to the model, and asks it to continue several times over. Then it compares the model’s continuations against your actual ending, counting how much they overlap in shared word sequences (n-grams).

The logic is simple once you see it. If a model originally wrote your text, then when you cut it off and ask the same model to finish, it tends to regenerate something close to what was already there. The machine agrees with itself. Human writing veers off in ways the model wouldn’t predict, so the overlap stays low.

Two things set DNA-GPT apart. First, the mechanic is generate-and-compare, not rewrite-and-rescore. Second — the practical kicker — it ships in a black-box variant that needs only the model’s generated text, plus a white-box variant that uses probabilities when you have them. The black-box mode runs against a plain API, where DetectGPT’s classic form really wants internal probability scores.

Fast-DetectGPT: the same idea, roughly 340 times faster

Fast-DetectGPT, from Bao and colleagues at ICLR 2024, looks at DetectGPT and asks a blunt question: do we really need to rewrite the text a hundred times to measure curvature?

Their answer is no. Instead of perturbing the passage and re-scoring each version, Fast-DetectGPT uses what the authors call conditional probability curvature. In rough terms, it samples alternative tokens from the model’s own distribution and estimates the curvature in something close to a single forward pass. No mask-and-fill model, no hundred re-scorings.

The payoff the paper reports lands on both axes. The authors clock about a 340x speedup over DetectGPT — and, by their measure, higher detection accuracy too, not a trade where you swap quality for speed. That’s why Fast-DetectGPT gets cited so often: it kept the elegant curvature idea and stripped out the expensive part.

A fair caveat: those numbers come from specific models and datasets in a research setting. They’re a strong signal that the approach is efficient, not a guarantee about your particular paragraph.

A side-by-side, in one scenario

Picture the same suspect paragraph — a tidy model-written summary of a city budget — fed to all three. The figures here are illustrative, not benchmarks.

DetectGPT rewrites it dozens of times, re-scores every version, sees nearly all of them drop sharply, and flags it. Solid verdict, but you waited while a long stack of forward passes ran. DNA-GPT chops the paragraph in half, asks the model to finish it a handful of times, sees the continuations share long phrases with the original ending, and flags the overlap — through an ordinary API call. Fast-DetectGPT scores it once, samples alternatives to estimate the curvature, and returns the same “likely machine” call in a fraction of the time.

Three roads, one neighborhood. None of them read the paragraph and understood it was about parking and property taxes. They measured statistics.

Method	Core mechanic	Model access	Speed
DetectGPT	Perturb text, re-score, measure curvature	Probability scores (white-box-ish)	Slow (~100 passes)
DNA-GPT	Truncate, regenerate, compare n-grams	Black-box or white-box variant	Moderate
Fast-DetectGPT	Estimate conditional probability curvature	Probability scores	Very fast (~340x DetectGPT)

What they all share — including the failures

For all their differences, the three converge on the same honest limits.

They output probabilities, not proof. A number reflecting statistical behavior is not a confession. False positives are real and documented: the 2023 Stanford study by Liang and colleagues found AI detectors flagged more than half of a set of TOEFL essays by non-native English writers as machine-generated, partly because that writing can be lower-perplexity. A clever method doesn’t get a pass on that.

They also lean on a source model. DetectGPT and Fast-DetectGPT are sharpest when they score text with the model that wrote it; DNA-GPT’s regeneration trick works best when the regenerating model matches the original. In real life you rarely know which model produced a piece of text, and that drains the signal.

And editing changes all three. Once a human reorders ideas, adds specifics, and varies the rhythm, the text stops sitting on the model’s peak and stops being something the model would regenerate verbatim. That’s not a loophole — it’s what real revision does to the statistics. For more on the moving parts, see our other guides on how detection actually works.

Frequently asked questions

What’s the main difference between DetectGPT and Fast-DetectGPT?

Both rest on the same idea — machine text sits on a probability peak, so it looks less likely when you nudge it. DetectGPT rewrites your text dozens of times and re-scores each version, which is slow. Fast-DetectGPT swaps the rewriting for a sampling-based estimate it computes in roughly one pass, which is why its authors report about a 340x speedup and, in their experiments, higher accuracy too.

How is DNA-GPT different from the other two?

DNA-GPT doesn’t perturb your text. It cuts the passage off partway, asks the model to continue it several times, then measures how much the model’s versions overlap with your original ending. Heavy overlap suggests a machine wrote it, because the model is agreeing with itself. It also has a black-box variant that only needs generated text, so it can run through a plain API where DetectGPT’s classic form wants probability scores.

Are these the same as GPTZero or Turnitin?

No. GPTZero and Turnitin are commercial products you log into and paste text. DetectGPT, DNA-GPT, and Fast-DetectGPT are research methods — algorithms from published papers, not websites. Commercial tools may borrow ideas from this research, but they run their own undisclosed systems. The thread tying them together is that they all read statistical signals rather than understanding meaning.

Does a faster method mean a more accurate one?

Not automatically, though here they moved together. Fast-DetectGPT reported both a big speed gain and higher accuracy than DetectGPT, which is a happy outcome rather than a rule. Speed and accuracy are separate properties, and paper numbers come from specific models and datasets that may not match your text. Treat them as a starting point, not a promise.

Can any of these prove a person used AI?

No. Every method outputs a probability based on statistical behavior, not proof of authorship. False positives are documented — in the 2023 Stanford study by Liang and colleagues, detectors flagged more than half of a set of non-native-authored TOEFL essays as AI. OpenAI retired its own classifier in July 2023 for low accuracy. A score is one input; if writing gets flagged, look at drafts and process, not the number alone.

The short version

DetectGPT, DNA-GPT, and Fast-DetectGPT are siblings, not strangers. DetectGPT rewrites and re-scores. DNA-GPT regenerates and compares. Fast-DetectGPT shortcuts the curvature math to get a similar answer far faster. They differ in mechanic, model access, and cost, but they end in the same place: a probability, not a verdict, and a reminder that the surest way to sound human is to write with specifics, rhythm, and the occasional surprise. Curious where your own draft lands? Run it through PaperBleach.