Offline & Private AI Text Detector

How this tool differs

Most AI detectors ask for something before they'll score your text: an email address, a monthly word limit, or eventually a credit card. This one asks for nothing. Paste your text, click Check for AI, and a score appears, the same way whether it's your first visit or your hundredth, because there's no account behind the scoring and never has been.

Inside your browser is exactly where every signal here runs, never on a remote server. The four Basic signals are plain JavaScript math, computed the instant you click Check for AI. Once loaded, the Advanced classifier model works the same way, entirely through WebAssembly, so nothing you paste is ever transmitted anywhere to be scored.

That local computation is also why this page keeps working with no internet connection at all, once you've loaded it a single time. CapyToolkit is installable as a browser app, and its service worker caches the page itself along with the scripts that run it, so a dropped connection mid-session doesn't interrupt a score that's already in progress. The classifier model caches separately, through the browser's own storage, the first time you download it, and every later visit reuses that copy instead of fetching it again.

None of that comes with a catch. Advanced mode isn't a paid tier hiding behind Basic, and there's no usage cap tied to a plan you'd need to upgrade out of. Every feature on this page, including the classifier, is free the same way every CapyToolkit tool is free: permanently, not as a trial of something bigger.

How AI text detection works

Every AI detector, including this one, is trying to answer the same question: does a piece of text look more like something a language model produced, or something a person wrote? Early detectors leaned almost entirely on perplexity, a measure of how surprising each word choice looks to a reference language model. Predictable word choices scored low on perplexity, and low perplexity got treated as a sign of machine authorship.

That approach ran into real problems once it left the lab. Because perplexity is measured against one specific model, a detector tuned for GPT-family output can misjudge text from Claude or Gemini, and the thresholds decay every time a new model ships. Most damagingly, simpler and more standard sentence structures score as predictable by default, and that pattern shows up disproportionately in writing from non-native English speakers.¹

Because of that history, this tool treats detection as an ensemble problem rather than a single perplexity number. Four independent, explainable signals run instantly on everything you type, and an optional local classifier model adds a second, more accurate opinion once you choose to load it. Nothing here claims to prove authorship. Every score is a statistical estimate, shown alongside the reasoning behind it, so you can judge for yourself instead of trusting one opaque percentage.

The four Basic signals

Sentence-length burstiness is the first signal, and it measures how much your sentence lengths vary across the whole document. Human writing tends to mix short, punchy sentences with longer, more complex ones, producing a high standard deviation in words per sentence. AI-generated text, by contrast, tends toward a narrower, more uniform range, so a low standard deviation pushes this signal's score up.

Transition density and word predictability

Transition-word density comes next, counting how often your text reaches for formal connectors like "furthermore," "in conclusion," or "it is important to note," relative to its length. Language models lean on these phrases far more heavily than typical human writing does, which makes density a cheap but genuinely useful tell. Word predictability works similarly but at a smaller scale: it checks your text's two-word phrases against a table of the 15,000 most common word pairs in English, built from a large public frequency corpus, and scores how often your phrasing lands on well-worn ground.²

Vocabulary variety across your document

The fourth signal, vocabulary variety, tracks lexical diversity using a length-normalized measure so a five-paragraph essay and a five-sentence comment get judged fairly against each other. Lower variety across a moving window of your text nudges the score toward AI-typical, since repeated word choices are cheaper for a model to generate than for a person to sustain naturally. Once a signal crosses the AI-typical threshold, it appears below your score as a plain-language reason, and you can toggle it on or off to highlight the exact sentences behind it in your text.

The Advanced classifier model

Advanced is the tool's default mode, so pasting at least 100 words is all it takes for the classifier to start downloading on its own, no button required. It's a RoBERTa-based model trained specifically to separate human from AI-generated text, converted to a compact, quantized format that runs entirely inside your browser through WebAssembly. A status line beneath the mode switcher tracks the download the whole time, so you always know whether the model is loading, ready, or still waiting on enough text.

The download itself is a one-time cost of about 120MB, and your browser caches the model afterward and reuses it on every later visit without fetching it again. Nothing about the download or the scoring afterward touches a server, since the model runs on your machine start to finish. That's the same one-time download behavior described earlier: once cached, later visits skip the network entirely for the Advanced classifier, the same way the page itself does once you've installed it.

Why the blend favors the classifier

Once loaded, the classifier's score replaces most of the weight behind your headline number, blended at 80% classifier and 20% Basic ensemble. That split isn't arbitrary. The classifier reports 99.28% AUROC on RAID,³ a large benchmark built specifically to stress-test AI detectors, while GLTR,⁴ a rank-and-frequency method that is the closest published analogue to this tool's own ensemble, scores roughly 62.6% accuracy under the same benchmark family.⁵ Weighting each method by how far it sits above random guessing produces a split close to 80/20 in the classifier's favor.

Worth saying plainly: AUROC and accuracy are not the same metric, and no single published study has scored both methods head-to-head under identical conditions. This is the strongest real evidence available, not a lab-perfect comparison, and it's presented here instead of a rounder, more confident-sounding number specifically because the honest version is more useful to you than a tidy one.

Reading your score, and its limits

Your headline score lands in one of three bands. Zero to 33 reads as Likely Human, 34 to 66 as Mixed or Uncertain, and 67 to 100 as Likely AI. Treat these bands as a starting point for judgment, not a verdict; a Mixed result usually means the four signals disagree with each other, which is itself useful information about how unusual or formulaic a piece of writing is.

Below the headline number, every signal that pushed your score toward AI-typical shows up as its own plain-language reason, so you never have to take the blend on faith. If Transition Density crosses the threshold but Sentence Rhythm doesn't, you know immediately that formal connector words, not sentence uniformity, are driving the result. That transparency is deliberate: a single black-box percentage tells you what a tool thinks, while a list of specific reasons tells you why. The highlighted sentences beneath your text work the same way, each tied to its own reason above them, so reviewing those exact sentences is faster than rereading the whole draft to figure out what moved the number.

None of that adds up to proof. Every score on this page is a statistical estimate built from patterns that correlate with AI generation, not a forensic record of what happened when the words were typed, and no detector on the market, free or paid, can close that gap. Because simpler, more standard sentence structures read as statistically predictable, non-native English writers are disproportionately likely to score higher here, exactly as documented in published research on this category of tool.¹ If that describes your writing, weigh the result accordingly rather than treating it as an accusation. A 100% Likely Human score is reassuring for the same reason: it means your writing didn't trigger the patterns this tool looks for, which is useful, but it isn't a certificate you could submit anywhere as evidence.

How it compares to other AI detectors

Every major AI detector on the market processes your text somewhere other than your own device, even the ones that don't charge for it. That distinction matters more than price does, because a server has to receive your text before it can score it, whether or not that server bills you afterward for the privilege. The table below compares this tool against five widely used detectors on the terms that actually separate them: whether you need an account, how much text you get before hitting a wall, what it costs, and whether your text ever leaves your browser to get scored at all.

Each competitor's row links to a page comparing it against this tool in more depth, including the places where that competitor genuinely does something this tool doesn't, like GPTZero's classroom integrations or Copyleaks' compliance certifications. Not one of the five listed here runs entirely inside your browser, and that's the one distinction no pricing change on their end can close.