Coreference Resolution and Why Chatbots Get Confused

Coreference resolution is deciding which mentions in a text refer to the same thing. It sounds like a linguist’s concern until you watch a retrieval-backed assistant answer the first question well and then fail completely on how much does it cost?

The task

Given a document, group the mentions into clusters that refer to one entity. In Acme Corp filed its report. The company said it expects growth. the cluster is {Acme Corp, its, The company, it}. Mentions include proper names, pronouns, definite descriptions (the company, the firm) and possessives. Anaphora — a pronoun pointing back — is the common case; cataphora points forward, and both occur.

It is deceptively hard because the correct answer often requires world knowledge rather than grammar. Terry Winograd’s classic pair makes this unavoidable: the trophy did not fit in the suitcase because it was too large versus … because it was too small. Identical syntax, and it refers to a different noun in each, resolvable only by knowing something about fitting objects into containers.

The datasets that define the hard cases

• The Winograd Schema Challenge (Levesque, Davis and Morgenstern, 2011/2012) formalised exactly the pairs above as an alternative to the Turing test: sentence pairs differing in one word, where that word flips the referent. It was designed to be unsolvable by statistical association, which is why it is a useful diagnostic and a poor training set.
• OntoNotes and the CoNLL-2012 shared task are the standard training and evaluation resource for full-document coreference, spanning newswire, broadcast, telephone conversation and web text. Nearly every published coreference score refers to this.
• GAP (Webster, Recasens, Axelrod and Baldridge, TACL 2018) is a gender-balanced corpus of ambiguous pronoun-name pairs, built after the authors observed that existing systems performed noticeably worse on feminine pronouns. It is the dataset to check if your pipeline makes decisions about people.

The point of naming these is that coreference is measured, publicly, on shared data, and the numbers are lower than for tagging or NER because the task is genuinely harder. Do not assume any component in your stack resolves pronouns reliably — verify it on your own text.

Why it breaks retrieval specifically

Here is the concrete failure, and it is extremely common. A user asks what does the enterprise plan include? Retrieval works, the answer is good. Then they ask how much does it cost?

That second query is embedded and sent to the index on its own. It contains no content words at all — how, much, does, it, cost. Its embedding is a generic price-question vector that is roughly equidistant from every pricing paragraph in the corpus, and its BM25 terms are all low-IDF. The system retrieves something plausible about pricing and answers about the wrong plan, confidently. Nothing errored.

This is why the failure is so persistent: the first turn of every demo works, because the first turn always contains its own context. The degradation starts at turn two and gets worse as the conversation goes on, which is also the shape described in multi-turn degradation. Passing the whole chat history to the retriever does not fix it — it makes the query vector an average of several topics, which is a different way to retrieve the wrong thing.

Decontextualise before you retrieve

The fix is a rewriting step between the user’s turn and the retriever: convert the follow-up into a standalone query that carries its own context.

REWRITE = """Rewrite the user's latest message as a standalone search
query. Replace every pronoun and definite reference with the entity it
refers to, using the conversation. Change nothing else. If the message is
already standalone, return it unchanged.

Conversation:
{history}

Latest message: {message}
Standalone query:"""

# turn 1: "what does the enterprise plan include?"  -> unchanged
# turn 2: "how much does it cost?"
#         -> "how much does the enterprise plan cost?"

Three implementation notes decide whether this helps or hurts. Use a small, fast model — this is a mechanical substitution, not a reasoning task, and it sits directly in the user’s latency path. Send the last two or three turns, not the whole history, because more context makes the rewriter hallucinate entities into the query. And log the rewritten query alongside the original: when retrieval goes wrong, the rewrite is the first place to look, and it is invisible unless you stored it. This is the same machinery covered in query rewriting, applied to the specific problem of pronouns.

A cheaper guard, worth having regardless: if a query contains a pronoun and no noun that appears in your corpus vocabulary, treat it as non-standalone. That is a five-line check and it catches the majority of cases without a model call. It also gives you a metric — the share of turns flagged as non-standalone — which is a far better early warning than a quality score, because it moves the moment your traffic shifts from one-shot questions to real conversations.

Is the classical system still worth it?

This is one of the places where the classical toolkit has genuinely been superseded for most purposes, and saying so matters as much as defending it elsewhere. A dedicated coreference model is a heavy dependency — the neural ones need a GPU to be fast, the older rule-based ones are brittle — and its output is a mention-cluster structure that most applications then have to interpret. A language model reading two turns and producing a rewritten sentence solves the application’s actual problem in one step.

Where a real coreference system still earns its place is when the clusters themselves are the product: building a knowledge graph where every mention of an entity must be linked to one node, counting how often each entity is discussed across a large corpus, or redacting every reference to a person including the pronouns — a requirement redaction work runs into immediately, because removing the name and leaving she throughout the paragraph is not anonymisation. In those cases you need offsets and exhaustive coverage over long documents, and that is what the classical formulation provides and a rewriting prompt does not.