Show, Don't TELL: Explainable AI-Generated Text Detection

Most AI text detectors operate as black boxes. They ingest a string of text and spit out an opaque probability score. For a professor deciding whether to accuse a student of academic dishonesty, a "95% AI" verdict is functionally useless. It lacks supporting evidence. If the detector cannot point to why it reached that conclusion, it creates a crisis of trust. A single false positive can derail a career.

The TELL architecture aims to solve this by baking explainability into the model's fundamental output. Instead of just returning a verdict, the system identifies specific "tells." These are segments of text that exhibit characteristic AI patterns. The model provides natural language justifications for each. It moves the needle from automated accusation to human-in-the-loop verification.

The Problem

Current state-of-the-art detectors focus almost exclusively on chasing higher accuracy metrics like AUROC (Area Under the Receiver Operating Characteristic curve, a measure of a model's ability to distinguish between classes). While this works well in controlled benchmarks, it fails in production settings. Users need to defend their decisions. As shown in, existing tools like ZeroGPT or Grammarly typically present a binary scale or a single percentage.

This "score-only" approach suffers from several failure modes. First, it struggles with out-of-distribution data (data not seen during training). This includes paraphrased text or newer model outputs. Second, it lacks transparency. When a detector incorrectly flags a historical document like the US Constitution, the user cannot see the reasoning. They cannot tell if the model simply recognized a high-frequency training pattern. Finally, the lack of granularity makes it impossible to distinguish a stylistic quirk from a structural hallucination. The research argues that accuracy alone does not resolve the need for insight.

How It Works

TELL departs from post-hoc attribution methods. Those methods use a separate model to explain a classifier's decision after the fact. Instead, TELL builds explainability into the generation process itself. The architecture follows a two-stage training pipeline .

1. Supervised Fine-Tuning (SFT): The authors first trained a GPT-OSS-120B base model. They used a custom dataset of 2,316 examples. These consist of domain-specific authorship annotations. The model learns a specific XML-inspired syntax. Unlike standard XML, this format places attributes after the text. This prevents the model from deciding on an annotation before it generates the span. The output includes <text> blocks and <span> tags. These tags contain the type (AI or human), a "why" explanation, and a confidence score.
2. Reinforcement Learning (GRPO): To move beyond mere format imitation, the model is refined using Group Relative Policy Optimization (GRPO). This is a reinforcement learning technique. The authors implement a curriculum. This curriculum prioritizes "strata" (subsets of data) with the highest reward variance. This focuses training on the most informative or difficult examples.

A critical technical innovation is Per-Token Advantage Decomposition. In standard RL (Reinforcement Learning), a single scalar reward is applied to all tokens in a sequence. This causes "format collapse." This is when the model forgets how to copy the original text because it is being penalized for explanation quality. To prevent this, the authors assign independent reward pools based on a token's role. Document-copy tokens receive zero advantage. This ensures faithful reproduction. Structural tokens receive a small fixed positive advantage to enforce syntax. Annotation tokens receive rewards based on the credibility of the explanation.

Numbers

The authors report that TELL achieves a competitive AUROC of 0.927 on their benchmark test set. This outperforms several established baselines [Table 2]. More importantly, TELL demonstrates superior recall in high-precision regimes. At a 1% False Positive Rate (FPR, the frequency of incorrect AI labels), TELL recovers 63.8% of AI documents. In contrast, the runner-up, MAGE, only recovers 4.2%. This delta represents a massive improvement in catching AI content while keeping false accusations low.

Regarding the quality of the "insights," the paper conducts a blinded listwise judge study. This compares TELL's explanations against human experts. The authors report a mean win-rate of 72.3% for TELL. This metric covers criteria like concreteness, falsifiability, and grounding. Qualitative analysis in shows that the model learns to cluster annotations into distinct semantic patterns.

These include "formatting slips" for human text or "cliché transitions" for AI. Furthermore, reveals that the model's internal reasoning branches logically.

It can pivot between commenting on global style versus local semantic contradictions.

What's Missing

While the results are impressive, there are gaps. First, the model is currently limited to English. The authors suggest it may generalize to other languages. However, the nuances of "tells" in multilingual contexts are not addressed.

Second, the paper acknowledges the risk of anchoring bias. This occurs when a user over-relies on a model's explanation. Even a correct explanation can lead a user to trust a wrong verdict. If the model provides a highly confident but flawed justification, the user may be misled.

Third, the evaluation relies heavily on LLM judges. The authors used a diverse panel of five model families to mitigate bias. However, a purely human-centric evaluation remains the gold standard. We need to know if these explanations truly empower a user or merely simulate expertise.

Should You Prototype This

Yes, if your use case involves high-stakes decision-making where auditability is required. If you are building a tool for educators or journalists, evidence is vital. Being able to point to a "hallucinated fact" or a "mechanical contradiction" is more valuable than a probability score.

The implementation complexity is high. The specialized GRPO setup and the need for high-quality SFT data are significant hurdles. However, the authors have released their code, data, and weights at https://github.com/ACMCMC/TELL. This lowers the barrier to entry. If you need a simple classifier for low-stakes spam, stick to basic baselines. But for any system where a human must defend a verdict, TELL is the blueprint.

Figures from the paper