When building natural language processing systems, we need a way to measure progress. Ideally, we want to know if a system successfully communicates with a human or effectively powers a downstream application. However, running human user studies or deploying full application pipelines for every model iteration is slow and expensive.
To solve this, the field historically relied on intrinsic metrics. In coreference resolution—the task of determining which mentions in a text refer to the same entity—we treat evaluation as an abstract mathematical clustering problem, using metrics like MUC, $B^3$, and CEAFe to measure how closely predicted clusters match a gold standard. In natural language generation tasks, like Referring Expression Generation (REG) or Question Generation (QG), we use automatic token-overlap metrics like BLEU or ROUGE to compare generated text against human-authored references.
These intrinsic metrics are fast, automated, and deterministic. But they suffer from a fundamental flaw: they measure form rather than function. A growing body of research demonstrates a severe disconnect between high benchmark scores and actual real-world utility.
Why Mathematical Clustering Fails Language Understanding
In coreference resolution, evaluating a system purely on its mathematical clustering accuracy introduces several blind spots that obscure true performance.
First, standard metrics often fail to weight errors in a way that reflects linguistic reality. As Bagga et al. pointed out, early metrics like MUC treat all clustering errors equally and fail to properly credit a system for correctly separating distinct single mentions. While newer metrics attempted to resolve this, they introduced their own mathematical anomalies; Chen et al. observed that the CEAFe metric frequently yields counterintuitive trends compared to MUC and $B^3$, making it difficult to determine whether a system is genuinely improving. Furthermore, because these are composite scores, Sukthanker et al. note that they routinely obscure critical flaws within individual components of the coreference pipeline.
Second, abstract clustering metrics assume a rigid, simplified model of language. For example, standard benchmarks struggle with plural mentions (such as "they" or "we") that refer to multiple distinct entities simultaneously. As Zhou et al. demonstrated, standard coreference metrics are structurally unsuited for evaluating plural expressions, requiring specialized adaptations to handle the overlapping entity relationships inherent to plural coreference.
Most fundamentally, treating coreference as a generic clustering problem hides how well a system supports higher-level applications. As Tuggener argues, a system can achieve a high intrinsic score by correctly resolving trivial pronoun clusters while failing on the critical, information-rich entity links that downstream tasks like summarization or information retrieval actually depend on.
Intrinsic Evaluation (Abstract Clustering)
[ Mention A ] --?--> [ Mention B ] ==> High Score if clusters match mathematically
Extrinsic Evaluation (Application Utility)
[ Coreference Engine ] ----> [ Question Answering System ] ==> Success only if the critical link is found
The Illusion of Text Generation Quality
A parallel issue exists in natural language generation. If a system generates a referring expression (e.g., "the blue chair") or a question, we often evaluate it by measuring its string similarity to a human reference. However, text similarity does not guarantee communicative success.
During the early shared tasks for referring expression generation, researchers began testing this alignment. In the GREC challenge, Belz et al. paired intrinsic metrics with an extrinsic approach that measured how generated expressions impacted downstream coreference resolution tools. Similarly, the TUNA challenges (Gatt et al.) combined automatic metrics with human-centric usability experiments, tracking practical outcomes like human reading time and target identification accuracy.
The results revealed a stark disconnect. By the conclusion of the TUNA-REG challenge, Gatt et al. found a persistent lack of consistent correlation between intrinsic measures (such as string accuracy or fluency) and extrinsic task performance. A system optimized to achieve high intrinsic scores could still generate expressions that confused human users or degraded downstream task performance.
This pattern holds true for more complex generation tasks like Question Generation (QG). While models are routinely optimized for token-overlap metrics like ROUGE or BLEU, Antoine et al. showed that these metrics fail to reflect real-world utility or user experience. When evaluating models based on actual user journey logs during a document discovery task, the authors found that a smaller, filtered QG model actually outperformed a large language model in facilitating efficient document discovery—a nuance completely missed by traditional intrinsic metrics.
The Extrinsic Turn: Evaluating by Doing
To bridge this gap, researchers have shifted toward extrinsic evaluation frameworks—assessing a component's quality based on its operational impact within a larger, real-world application pipeline.
This shift has exposed significant vulnerabilities in models optimized solely for standard benchmarks. For instance, Chai et al. integrated state-of-the-art coreference resolvers into a community-based question answering (CQA) pipeline. They discovered that while these models excelled on standard intrinsic benchmarks, their impact on the actual CQA task was minimal, and in some cases, even negative. Models optimized for abstract clustering benchmarks were failing to capture the specific linguistic phenomena and entity relationships critical to practical question answering.
Benchmark Optimization vs. Real-World Utility
┌────────────────────────────────────────────────────────┐
│ Model optimizes for Intrinsic Metrics (MUC, B³, BLEU) │
└───────────────────────────┬────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Model achieves State-of-the-Art on Benchmark Dataset │
└───────────────────────────┬────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ CRITICAL DISCONNECT: Model degrades performance when │
│ deployed in downstream tasks (CQA, User Navigation) │
└────────────────────────────────────────────────────────┘
To address this disconnect, the literature proposes three main paths forward:
- Application-Specific Metrics: Instead of relying on generic clustering metrics, Tuggener proposes designing automated metrics that directly mimic how downstream applications consume data, providing more interpretable and structurally relevant scores.
- Behavioral and Interaction Logging: In generation tasks, rather than comparing text to static human references, systems can be evaluated dynamically. For example, Antoine et al. transformed user interaction logs into behavioral graphs, measuring how effectively generated text guided users through an information space.
- End-to-End Pipeline Validation: As demonstrated by Chai et al. and early work in information extraction (Kehler et al.), true validation requires embedding components directly into downstream tasks to verify that performance gains on paper translate to tangible benefits in practice.
Ultimately, language is a tool for communication and action, not a static artifact to be clustered or matched. The collective evidence across these fields demonstrates that optimizing for intrinsic form does not guarantee extrinsic utility, forcing a necessary paradigm shift toward task-aligned evaluation.
Key Foundational Work
The GREC Challenge 2008: Overview and Evaluation Results (2008) — contributed 2 concept elements to this direction.
Entity-Based Cross-Document Coreferencing Using the Vector Space Model (1998) — contributed 1 concept elements to this direction.
Information Extraction Research and Applications: Current Progress and Future Directions (1998) — contributed 1 concept elements to this direction.