Coreference resolution is the task of identifying all expressions in a text that refer to the same real-world entity and grouping them into clusters, so that a name, a later pronoun and a descriptive phrase are recognized as one referent. In Speech & language AI, it is a core component of discourse-level understanding: without it, a system reading “Maria signed the contract after she reviewed it” cannot tell that “she” means Maria and “it” means the contract.
The task sits between sentence-level analysis, such as named entity recognition and dependency parsing, and higher-level applications such as question answering, summarization and information extraction. Its output is a set of mention clusters, often called coreference chains, that downstream components use to merge facts scattered across sentences.
How coreference resolution links mentions
Coreference resolution works in two stages: mention detection, which finds every span that could refer to an entity, and mention linking, which decides which spans share a referent. A mention can be a proper name (“Maria Lopez”), a nominal phrase (“the new manager”) or a pronoun (“she”, “her”, “it”).
Linking relies on several kinds of evidence at once. Grammatical agreement in number, gender and person rules out many candidates, syntactic constraints such as binding theory block impossible pairs, salience favors recently mentioned subjects, and semantic compatibility checks whether “the company” can describe “Acme”. Modern neural models learn these signals jointly from annotated text rather than from hand-written rules.
The following table shows the main mention types and the difficulty each one typically creates.
| Mention type | Example | Typical difficulty |
|---|---|---|
| Proper name | Maria Lopez, Lopez | Aliases, abbreviations and partial names |
| Nominal phrase | the new manager | Requires world knowledge to match descriptions |
| Personal pronoun | she, they, it | Many candidates and little lexical content |
| Demonstrative | this, that proposal | May refer to events or whole clauses |
| Zero anaphor | omitted subject in Spanish or Japanese | No surface form to detect |
Model architectures and their trade-offs
Coreference systems have evolved from rules to end-to-end neural span ranking, and each generation trades accuracy against interpretability and cost. Early sieve-based systems applied ordered rules, from exact string matches to pronoun heuristics, and remain useful where transparent behavior matters more than peak accuracy.
The mention-pair model classifies every pair of mentions independently, which is simple but can produce inconsistent clusters. Mention-ranking models instead choose the single best antecedent for each mention, and entity-level models compare a mention against a whole cluster. Current state-of-the-art systems use transformer encoders that score candidate spans and antecedents together, while generative approaches with large language models rewrite text with explicit cluster markers.
The table below compares the main architectural families.
| Approach | Core idea | Strength | Weakness |
|---|---|---|---|
| Rule-based sieves | Ordered deterministic rules | Predictable and explainable | Low recall on unusual text |
| Mention-pair classifier | Binary decision per pair | Easy to train | Inconsistent transitive clusters |
| Mention ranking | Pick best antecedent per mention | Good accuracy for pronouns | Ignores cluster-level evidence |
| End-to-end span model | Jointly scores spans and links | High accuracy on benchmarks | Quadratic cost on long documents |
| Generative LLM | Produces annotated output text | Flexible across domains | Expensive and harder to constrain |
Span-based models consider a large number of candidate spans, so their memory use grows quickly with document length. Practical systems prune candidate spans aggressively and process long documents in overlapping windows, which can lose links between mentions that are far apart.
Coreference compared with related language tasks
Coreference resolution is often confused with neighboring tasks, but it differs in what it connects and why. Named entity recognition labels spans by category, while coreference groups spans by identity, including pronouns that carry no category at all.
| Task | Question it answers | Relation to coreference |
|---|---|---|
| Named entity recognition | Which spans are names, and of what type | Supplies candidate mentions |
| Entity linking | Which knowledge base entry is meant | Links a whole cluster to one external ID |
| Anaphora resolution | What a pronoun or reference points back to | A subset focused on referring expressions |
| Relation extraction | How two entities are related | Uses clusters to combine facts across sentences |
| Word sense disambiguation | Which meaning a word has | Concerns meaning, not identity of referents |
The distinction between anaphora and coreference matters in practice. In “Every student brought their laptop”, “their” is anaphoric but does not corefer with a specific person, and many annotation schemes treat such bound or generic references differently.
Evaluation metrics and benchmark data
Coreference systems are evaluated by comparing predicted clusters with gold clusters, and no single metric captures all errors, so results are usually reported as the average of several. The CoNLL F1 score, the mean of MUC, B-cubed and CEAF-e, is the standard summary figure on the OntoNotes benchmark.
| Metric | What it measures | Known bias |
|---|---|---|
| MUC | Minimum links needed to align clusters | Ignores singleton mentions |
| B-cubed | Precision and recall per mention | Inflated when many singletons exist |
| CEAF-e | Best one-to-one alignment of entities | Can undervalue partially correct clusters |
| LEA | Link-based score weighted by entity size | Less widely reported |
Strong English systems reach CoNLL F1 scores roughly in the low 80s on OntoNotes, but performance drops noticeably on out-of-domain text such as clinical notes, legal contracts or transcribed conversation. Reported numbers are therefore only meaningful together with the dataset and annotation guidelines used.
Practical use, limitations and common mistakes
Coreference resolution adds the most value where facts about one entity are spread across many sentences: document summarization, contract analysis, news monitoring, clinical record extraction and conversational assistants that must track what “it” means across turns. In spoken dialogue, it also interacts with speaker diarization, because “I” and “you” change referent with every speaker turn.
- Error propagation: a single wrong link can merge two people into one cluster and corrupt every downstream fact.
- Gender and pronoun bias: models trained on skewed data may resolve “the nurse” and “the doctor” by stereotype rather than by context.
- Long-distance links: windowed processing can miss references that span many paragraphs.
- Event coreference: linking “the merger” to “Acme acquired Beta” is harder than linking entities and is often unsupported.
- Language coverage: pro-drop and low-resource languages have far less annotated data, so accuracy is lower.
A common practical mistake is to treat coreference output as certain. Robust pipelines keep confidence scores, apply conservative merging thresholds for high-stakes uses and allow human review where wrong identity would cause real harm.
The simple explanation
When people read, they constantly keep track of who is who. If a story says “Tom met his sister, and he gave her a book”, everyone understands that “he” is Tom and “her” is the sister. Coreference resolution is the way a computer learns to do the same thing: it groups together all the words that point to the same person or thing.
Think of it as drawing lines between words that belong together. Once a computer has those lines, it can collect everything a text says about one person, even when that person is called by a name in one sentence and by “she” or “the director” in the next. Without this step, a machine reads a document as a pile of disconnected sentences.
How it is used in practice
A legal technology team builds a tool that reviews supply contracts of 20 to 40 pages. The contracts introduce parties by full name, then call them “the Supplier”, “the Buyer”, “it” or “such party” for the rest of the document. The team runs a transformer-based coreference model after named entity recognition, so that every obligation sentence can be attributed to the correct party.
Because the documents exceed the model’s input length, the pipeline processes overlapping windows of about 512 tokens and then merges clusters that share a defined term. Links with low confidence are flagged for a paralegal rather than merged automatically.
The result is a table of obligations grouped by party. Reviewers report that attribution errors fall sharply compared with sentence-by-sentence extraction, and the remaining errors concentrate on ambiguous phrases such as “either party”, which the team now handles with a dedicated rule.