Entity Resolution Across Heterogeneous Web Sources

Entity resolution across heterogeneous web sources fails through four compounding mechanisms, namely identity collapse, semantic fragmentation, temporal discontinuity, and semantic vulnerability. Reliable AI reasoning therefore requires more than language understanding or relevant search results. It requires retrieval infrastructure that preserves an entity’s identity across sources, structures, time, and conflicting claims before the model begins to reason.

Why entity resolution is harder than string matching — and why that gap now matters

Entity resolution identifies data references that designate the same real-world entity. Character-string comparison answers a narrower question about how similar those references look. A system can understand every word in a retrieved document without establishing whether the document describes the person, organization, or product the query targets.

The Fellegi-Sunter probabilistic record linkage model dates to 1969, so the underlying problem is not new. What has changed is where identity decisions occur. LLMs, retrieval-augmented generation pipelines, and autonomous agents now make or inherit those decisions despite not being designed to make them reliably.

For example, a product may appear as “Apple iPhone 14 (Blue)” in one source, “IPH14-BLU” in another, and an image with minimal text in a third. No string matcher resolves those representations reliably. Clinical datasets likewise express the same condition as “Hypertension,” “High blood pressure,” and “HTN,” despite their lack of lexical overlap. In RAG, the error can travel from indexing through retrieval to generation, while an agent can redirect later tool calls, including its apparent verification, toward the wrong entity.

Identity collapse: when name ambiguity and popularity bias merge distinct entities into one

Daniel Beránek’s preprint identifies identity collapse under name ambiguity and popularity bias as the first of four interconnected anomalies. Its distortion has a clear direction. When several entities share a name, retrieval systems and LLMs disproportionately surface the most prominent bearer, allowing that entity to crowd out the others. The research literature calls this “entity overshadowing,” but the practical consequence is straightforward. A niche or recently created entity can become effectively invisible even when the query nominally targets it.

Embedding-based retrieval ranks semantic similarity. Documents about a famous entity can therefore score highly for a query about a less-famous namesake, although they concern the wrong referent. A strong retrieval score can give the generation stage evidence that looks useful but is about the wrong identity. Because the ranking mechanism rewards similarity rather than disambiguation, correcting a name field alone does not address the structural bias.

Multilingual sources add another layer of ambiguity. “München,” “Munich,” and “Munique” refer to the same city, while a name resembling that of a different famous entity in another language can invite cross-language overshadowing. The system must tell aliases from namesakes, since names that look alike are not enough to show that they refer to the same entity. For agents, that distinction governs action as well as description. A supervisor that conflates two similarly named organizations can delegate tasks about the wrong organization to every specialist below it.

Semantic fragmentation: when the same entity lives in incompatible silos and retrieval only ever sees part of it

Identity collapse retrieves the wrong entity, whereas semantic fragmentation retrieves the right entity without assembling its representation. Beránek’s preprint identifies this as semantic fragmentation across data silos. Relevant information exists, but incompatible structures prevent the system from combining it into a coherent account. A retrieval result can therefore be accurate about one part of an entity while omitting the context needed to reason about the whole.

Moslemi et al. document structural differences across JSON, XML, relational tables, knowledge-graph triples, and images, together with schema variation, attribute mismatches, and nesting differences. An address stored as one string and the same address split into street, city, and postcode fields require schema alignment before they can be joined. Meaning also depends on the source’s context. Job titles such as “Senior” and “Manager” do not necessarily denote equivalent roles across organizations or languages.

The survey also reports that deep learning-based entity matching methods become much less accurate when they move from clean benchmarks to domains with different schemas or semantics. Generalizing to unfamiliar names is not the same as generalizing to unfamiliar structures. Retrieval tuning alone cannot supply the missing alignment. In a RAG pipeline, document chunking that does not account for the entity can also split an organization’s founding date from its current leadership. If only one chunk reaches the model, it may generate a confident answer that is faithful to the retrieved text but unsupported as a complete account of the entity.

Temporal discontinuity: when the world has moved on but the index has not

Structural alignment does not solve the problem of change. Organizations rename, merge, or dissolve, people change roles, and products are discontinued. Beránek’s preprint identifies temporal discontinuity as the anomaly that arises when those changes outpace indexed representations. The system may describe an entity consistently while describing a form of it that no longer exists.

Unlike fragmentation, this failure does not require information to be scattered across silos. Older and newer representations can coexist in the same index without a principled way for retrieval to prefer the current one. Static training data adds another stale signal. When a model’s parametric knowledge reflects an earlier state and retrieval returns that same state, the retrieved evidence reinforces the model’s earlier knowledge. Agreement between the two can produce confidence without currency.

An agent’s verification step is particularly exposed to this mechanism. A second query against the same stale index can return apparent confirmation of the original claim, even though the new result is not independent of the original error. In production, questions about current leadership, regulatory status, or product pricing require a continuously refreshed retrieval layer. Even that requirement must distinguish “indexed recently” from “indexed correctly as of this moment,” because a recent indexing event does not by itself establish that the entity representation is current.

Semantic vulnerability: how incomplete or conflicting retrieved context distorts entity reasoning

Correct identification and current records still do not establish that every retrieved claim about an entity is sound. Beránek’s preprint identifies semantic vulnerability of retrieval context as the fourth anomaly. Here, the entity can remain stable while surrounding evidence distorts its characterization. A retrieval layer with no native mechanism for adjudicating conflicting claims cannot determine which characterization should guide the model merely by returning relevant text.

This can happen by accident when sources disagree and no one is trying to manipulate the system. An organization’s official site may give one founding date while a secondary source that is widely indexed gives another. Both results concern the correct organization, but they do not support a single unqualified answer. The model may blend the claims or arbitrarily favor one without signaling the conflict to the user. This differs from fragmentation because the immediate problem is not simply that a piece is missing, but that the evidence does not support the characterization being generated.

Someone can also exploit that weakness on purpose by injecting content into a retrieved page. Such content can target the attributes of a product, person, or organization rather than directly instructing the model to change its behavior, allowing manipulation without triggering standard safety filters. This is a security concern. In a multi-agent system, a supervisor can accept that characterization from a retrieval sub-agent and pass it into downstream actions. Those agents may have no basis for challenging the claim because the evidence needed to assess it never reaches them.

How the four failure modes cascade in RAG and agentic pipelines

The four anomalies form a propagation chain. Beránek’s preprint traces how failures move from indexing through retrieval to generation, and how an earlier misidentification can redirect subsequent agent steps. The canonical RAG sequence embeds a query, retrieves top-k chunks, and passes them to an LLM. None of those operations inherently validates entity identity. If retrieval supplies evidence about the wrong namesake, generation has no identity check on which to base a correction.

The ReAct pattern makes the dependency explicit through its loop of thought, tool call, observation, and repetition. A misidentified entity in the first thought changes the next tool call, whose observation then becomes the basis for the following thought. Each iteration can deepen the original error. If the observations are also fragmented, stale, or manipulated, the loop gains more text without gaining a sounder entity representation.

In multi-agent delegation, specialists work with the entity the supervisor has assigned, so working separately does not mean they have each checked that it is the right target. Temporal discontinuity can then make a later verification query appear to confirm the shared premise. The architecture contains several steps, but they can depend on the same defective representation. Fixing one stage in isolation leaves the other stages able to reproduce or amplify the error.

Gartner projects that 60% of AI projects unsupported by AI-ready data will be abandoned by the end of 2026. The engineering implication follows from the dependencies themselves. A system cannot count on generation, delegation, or repeated retrieval to fix evidence about identity when those stages just receive that evidence from earlier steps.

What entity-aware retrieval infrastructure must do differently at each stage of the pipeline

The design response is to make entity identity a first-class concern throughout the retrieval pipeline. Against identity collapse, retrieval must go beyond lexical and embedding similarity to persistent identifiers. Stable IDs provide continuity through aliases and name changes. Mechanisms including @id in JSON-LD, Wikidata Q-ID, and ISNI enable canonical linking without making identity depend on which namesake dominates a similarity ranking.

Against fragmentation, source selection must cover heterogeneous formats and schemas, while alignment logic assembles entity representations before they enter the context window. Chunking must keep the entity context intact, which requires more than following document boundaries alone. Structure cannot be recovered through relevance scores alone. Moslemi et al. identify multimodal matching and deeper integration with knowledge graphs as directions for greater robustness. Those capabilities work with sources where evidence of identity goes beyond text or a shared table schema.

Against temporal discontinuity, the index must be continuously refreshed rather than periodically updated, and retrieval must prefer the most recently indexed authoritative representation when versions coexist. Authority and freshness must work together here. Static training data cannot supply current knowledge of changing entities, while live web retrieval cannot correct that limitation if its own index remains stale. Temporal versioning is therefore part of entity resolution.

Against semantic vulnerability, retrieved context must be ranked and filtered before entering the prompt, with provenance and source quality assessed at retrieval time. Conflicting claims must be flagged. Context shaping must preserve enough evidence for the system to distinguish a supported characterization from a disputed or manipulated one.

These requirements place responsibility at the web knowledge infrastructure layer, spanning source crawling, entity-aware parsing, disambiguation, temporal versioning, and context shaping. Wrapping third-party search results does not provide that control. A 150–250 character snippet with no entity structure is a pointer to content that may itself be fragmented, stale, or conflicting. Infrastructure built for this task must deliver machine-ready content that is selected, filtered, ranked, and shaped around the entity the system is meant to reason about.