Unseen Entity KGQA Overview

• Unseen Entity KGQA is a paradigm addressing question answering over knowledge graphs where entity-specific facts are unreliable, missing, or unseen at test time.
• It employs strategies such as semantic parsing with query templates, entity-independent graph representations, and zero-shot transfer to overcome challenges in entity grounding.
• Recent research highlights issues like candidate recall, hallucination control, and benchmark mismatch while proposing methods like retrieval augmentation and inductive reasoning.

Unseen Entity KGQA denotes the family of knowledge-graph question answering settings in which a system cannot rely on fixed memorization of entity-specific facts or prelearned entity IDs at test time. Recent work uses several adjacent formulations rather than a single canonical term: out-of-vocabulary entities and relations in semantic parsing, out-of-knowledge-graph entities, full-inductive train/test separation over entity sets, long-tail or obscure entities that are weakly represented in parametric memory, zero-shot transfer to an unseen KG, and the case where the head entity mentioned in a question cannot be matched because the KG is incomplete (Diomedi et al., 2021, Wang et al., 2023, Xie et al., 2024, Toroghi et al., 20 Apr 2025, Agarwal et al., 2023, Yan et al., 2 Aug 2025). Across these formulations, the shared technical problem is how to ground, retrieve, and reason over graph evidence when entity identity itself is unreliable, unavailable, or non-transferable.

1. Conceptual scope and formal variants

The literature treats unseen-entity KGQA as a spectrum rather than a single benchmarked setting. In full-inductive graph reasoning, training and test entities are explicitly disjoint, as in the condition $$\mathcal{E}_{train}\cap\mathcal{E}_{test}=\emptyset$$ used for inductive KGC (Xie et al., 2024). In modular semantic parsing, the emphasis is instead on out-of-vocabulary test entities and relations that a seq2seq model cannot emit reliably as SPARQL identifiers (Diomedi et al., 2021, Purkayastha et al., 2021, Banerjee et al., 2023). In practical LLM-era evaluation, several benchmark papers operationalize the problem through long-tail or obscure entities whose facts are unlikely to be robustly stored in parametric memory, even if those entities are not strictly absent from pretraining corpora (Toroghi et al., 20 Apr 2025, Guo et al., 2024, Toroghi et al., 13 May 2026). A still stricter formulation defines Unseen Entity KGQA as answering a question $\mathcal{Q}$ over an incomplete KG $\mathcal{G}$ when the head entity mentioned in the question cannot be matched and did not appear in $\mathcal{G}$, while the relation remains in the KG, written as $$\mathcal{F}:(\mathcal{Q},\mathcal{G})\implies\mathcal{A}$$ with $\mathcal{R}\in\mathcal{G}$ (Yan et al., 2 Aug 2025).

These formulations are not interchangeable. The out-of-vocabulary setting assumes that the entity may exist in the KG and may be linkable, but not generatable as a decoder token sequence. The long-tail setting assumes that the entity is present and often linkable, but poorly memorized by the LLM. The OOKG and full-inductive settings assume that the entity was absent from training-time graph representation. The incomplete-KG setting assumes that the entity may be known to the LLM but is unavailable as a graph node at retrieval time. This suggests that unseen-entity KGQA is best understood as an umbrella problem defined by the failure of entity-specific parametric shortcuts rather than by one universal split protocol.

Operationalization	Representative papers	Salient property
OOV semantic parsing	(Diomedi et al., 2021, Purkayastha et al., 2021, Banerjee et al., 2023)	Exact KG IDs are hard to emit at test time
Long-tail / obscure entity KGQA	(Toroghi et al., 20 Apr 2025, Guo et al., 2024, Toroghi et al., 13 May 2026)	Popularity, not strict holdout, is the stressor
Incomplete-KG unseen head entity	(Yan et al., 2 Aug 2025, Zhou et al., 16 Dec 2025)	Direct entity-centered retrieval is unavailable
Inductive graph reasoning	(Wang et al., 2023, Xie et al., 2024)	Test entities are absent from training graph
Zero-shot unseen-KG transfer	(Agarwal et al., 2023, Georgiev et al., 28 Jan 2026)	No QA supervision on the target KG

2. Decoupling query structure from entity identity

A major line of work addresses unseen entities by separating structural semantic parsing from exact KG grounding. ElNeuQA is the clearest early example: it replaces full-query generation with a query template containing placeholders such as <obj1> and <obj2>, delegates entity handling to entity linking, and then uses slot filling to assign linked entities to the template (Diomedi et al., 2021). The motivating empirical result is that in a pure NMT baseline, 91.1\% of errors involved the output query containing the wrong set of entities. On LC-QuAD 2.0*, template generation is markedly easier than full-query generation; for ConvS2S, exact-match accuracy rises from 3.3 to 34.3, and the final KGQA $F_1$ improves from 16.4 to 26.9. The gain is specifically entity-facing: for ConvS2S, the share of generated queries containing the correct entities rises from 10.0\% in pure NMT to 58.2\% in ElNeuQA. The limitation is equally explicit: entity robustness improves, but unseen query-template generalization remains poor, with 0\% exact accuracy on WikidataQA.

"Knowledge Graph Question Answering via SPARQL Silhouette Generation" takes a closely related approach but makes the abstraction even more explicit (Purkayastha et al., 2021). Stage I generates a masked “SPARQL silhouette,” with entities and relations abstracted to reduce vocabulary and handle unseen test items; Stage II then uses a Neural Graph Search module to recover graph-valid relations. On LC-QuAD-1, Stage I attains 83.08 $F_1$ under a noise-free linker but only 25.59 under “Full Noise.” Stage II raises this realistic-case result to 37.05 $F_1$, and the paper reports a 3.72\% $F_1$ improvement over the previous state of the art. The paper’s own framing is directly aligned with unseen-entity KGQA: masking helps both with “handling test entities/relations that are unseen during training” and with reducing vocabulary size.

GETT-QA addresses the same bottleneck from the decoder side (Banerjee et al., 2023). Instead of generating opaque Wikidata IDs, it generates entity labels, relation labels, and a truncated KG embedding string; grounding then proceeds by Elasticsearch label search, embedding-based entity reranking, and BERT-based relation ranking. On LC-QuAD 2.0, GETT-QA without truncated embeddings scores $\mathcal{Q}$0, while the full model reaches $\mathcal{Q}$1; on SimpleQuestions-Wikidata, the improvement is smaller, from $\mathcal{Q}$2 to $\mathcal{Q}$3, because entity mentions there nearly match gold labels. The paper’s error analysis is especially revealing for unseen-entity use: “More than 95\% of questions where the correct entities and relations were in the top-6 and top-3 candidates respectively, the right answer was eventually produced,” but “only in 41\% of the questions, the correct entities and relations were found within the top-k candidates.” This locates the main bottleneck at candidate recall and disambiguation rather than program synthesis itself.

A differentiable alternative appears in "End-to-End Entity Resolution and Question Answering Using Differentiable Knowledge Graphs" (Oliya et al., 2021). Instead of discrete entity linking followed by symbolic reasoning, the model computes a soft entity distribution $\mathcal{Q}$4 over KG entities from question spans and candidate entity features, then performs differentiable multi-hop traversal with

$\mathcal{Q}$5

This lets uncertainty about entity resolution flow directly into answer prediction. The stand-alone model, trained only from question text and answer entities, reaches 45.0 Hits@1 on WebQSP and 68.2 accuracy on SimpleQuestions without gold entities at inference time. Its practical limitation for unseen-entity KGQA is explicit: candidate generation is still based on exact title/alias lookup, so the approach is much stronger for unseen-in-training but lexically retrievable entities than for genuinely unlexicalized ones.

3. Entity-independent graph representations and inductive reasoning

A second line of work attacks unseen entities on the graph side by replacing dedicated entity embeddings with structure-derived representations. "Sequence-to-Sequence Knowledge Graph Completion and Question Answering" replaces atomic entity vectors with textual mentions processed by an encoder-decoder Transformer (Saxena et al., 2022). The method is not evaluated on explicit unseen-entity splits, but it removes one vector per entity and reports model-size reductions of up to 98\% relative to conventional KGE models while remaining competitive on large-scale KGC and incomplete-KG QA. Its relevance lies in changing the representational bottleneck: entities can be processed compositionally as text rather than only as learned IDs.

VNC addresses the OOKG problem more directly (Wang et al., 2023). The setting assumes a training graph over observed entities and an auxiliary test-time set in which each triple contains exactly one unseen entity and one observed entity. VNC combines rule mining, rule inference, and embedding learning, introduces virtual neighbors for OOKG entities, and assigns them soft labels through a rule-constrained convex program. Its triple score uses

$\mathcal{Q}$6

and fuzzy-rule constraints regularize inferred triples. The empirical effect is substantial: on YAGO37 Subject-10, VNC raises MRR from 46.5 for VN network to 50.6; on FB15K Subject-10, from 46.3 to 54.3. The method is not a QA system, but it is directly relevant to unseen-entity KGQA whenever the answering system must build representations for newly emerging entities from sparse observed neighbors.

GLAR extends the inductive argument to full train/test entity disjointness (Xie et al., 2024). Rather than extracting an enclosing subgraph for every candidate triple, it extracts one shared opening subgraph around the query entity and reasons over it with local and global anchors. Local anchors include the center node and one-hop neighbors represented by relation roles; global anchors are obtained by clustering entity-independent relational features. The final score is

$\mathcal{Q}$7

with $\mathcal{Q}$8 built from the opening-subgraph embedding, the query-entity embedding, and the relation embedding. GLAR reports average Hits@10 of 93.55 on WN18RR-ind, 95.06 on FB15k237-ind, and 94.38 on NELL995-ind, and runtime speedups over GraIL ranging from about 2.2x to 26.9x. For unseen-entity KGQA, the important idea is not the KGC score itself but the entity-independent reasoning recipe: a single query-centered subgraph, transferable anchors, and one-pass candidate ranking.

NuTrea provides a KGQA-native version of the same intuition (Choi et al., 2023). The paper explicitly argues that KG nodes are often proper nouns or encrypted codes, so node identity is uninformative. It therefore initializes nodes from relation statistics rather than entity names through Relation Frequency-Inverse Entity Frequency (RF-IEF), with

$\mathcal{Q}$9

and adds a Backup step that probes unreached subtree regions to augment past-oriented search embeddings. On WebQuestionsSP, the full model reaches 77.4 Hits@1 and 72.7 $\mathcal{G}$0; on CWQ, 53.6 Hits@1 and 49.5 $\mathcal{G}$1. The paper does not report entity-disjoint evaluation, but its explicit concern with encrypted and semantically uninformative entities makes it directly pertinent to unseen-entity KGQA.

4. Benchmark ecology: strict induction, long-tail entities, and commonsense KGQA

Benchmark design is currently split between strict inductive formulations and practical low-memorization proxies. CoLoTa is the strongest recent benchmark for the latter (Toroghi et al., 20 Apr 2025). It contains 3,300 queries, evenly split between question answering and claim verification, and every example is a binary decision with $\mathcal{G}$2. Each item includes a natural-language query, anchor-entity QIDs, a relevant Wikidata subgraph, an explicit natural-language inference rule, and stepwise reasoning grounded in KG triples. Long-tailness is operationalized by the number of Wikidata triples containing the entity. The benchmark is especially relevant because it keeps all factual support in Wikidata while requiring commonsense reasoning on top of retrieval. The performance degradation is sharp: on question answering, OpenAI-o1 drops from 0.88 on the original head-entity queries to 0.67 on CoLoTa under zero-shot CoT; on claim verification, it drops from 0.93 to 0.71. GPT-4o and Llama-3.3-70B show similar or larger degradations.

CR-LT-KGQA is an earlier but smaller benchmark with the same design thrust (Guo et al., 2024). It contains 350 boolean queries—200 question-answering items and 150 claim-verification items—derived from StrategyQA and CREAK and rewritten around long-tail Wikidata entities. Each entry provides the query, anchor QIDs, a relevant Wikidata subgraph, an inference rule, and reasoning steps. Its baseline result makes the entity-popularity effect explicit: GPT-3.5 Turbo with zero-shot CoT falls from 0.70 to 0.32 accuracy on the QA task and from 0.89 to 0.35 on claim verification when the original queries are rewritten into long-tail form. The paper further reports that reasoning scores remain comparatively stable while factual grounding deteriorates, suggesting that low-popularity entities primarily stress knowledge access and hallucination control rather than only abstract reasoning.

CommonWhy generalizes the same logic to abductive causal commonsense (Toroghi et al., 13 May 2026). It contains 15,000 why questions, each with anchor QIDs, a relevant Wikidata subgraph, a natural-language commonsense axiom, and one or more valid causal explanations. The benchmark is explicitly framed as a KGQA task because all supporting facts are present in Wikidata, but the answer is a free-form explanation rather than an entity ID. Performance again declines from head to long-tail entities across all evaluated LLMs and KGQA methods. On the long-tail split, correctness is 67.93\% for OpenAI-o3, 57.09\% for GPT-5.1, 56.22\% for KGR, and only 18.48\% for KB-Binder; the head split is consistently higher or roughly equal for the same models. Several benchmark papers explicitly note the same caveat: these long-tail splits are highly relevant to unseen-entity KGQA, but they are not canonical entity-disjoint protocols (Toroghi et al., 20 Apr 2025, Guo et al., 2024, Toroghi et al., 13 May 2026).

5. Retrieval, execution, and reasoning when direct entity support is weak or missing

Zero-shot and retrieval-grounded systems push the field beyond fixed train/test graph assumptions. BYOKG is the clearest example of zero-shot KGQA over an unseen KG (Agarwal et al., 2023). It explores the target KG symbolically, generates synthetic question-program exemplars, and answers real questions through bottom-up retrieval-augmented program synthesis. The gains over a zero-shot baseline are large: +27.89 $\mathcal{G}$3 on GrailQA, +59.88 on MetaQA, and +46.33 on MatKG. With a stronger base LLM, BYOKG even exceeds Pangu-FT by 7.08 $\mathcal{G}$4 on GrailQA’s zero-shot split. For unseen-entity KGQA, its key contribution is methodological: no target-KG QA supervision is needed, and reasoning is organized around structural exemplars rather than memorized entity-specific training pairs.

UltRAG moves in a more systems-oriented direction by letting an LLM generate a structured graph query and delegating execution to a neural query executor (Georgiev et al., 28 Jan 2026). The framework operates over fuzzy sets

$\mathcal{G}$5

uses embedding-based entity linking and personalized PageRank to localize large KGs, and executes the query with ULTRAQUERY rather than symbolic traversal. On GTSQA, ULTRAG-OTS reaches 92.66 Hits, 91.05 Recall, and 89.29 $\mathcal{G}$6, outperforming SubgraphRAG’s 84.34, 81.66, and 81.62. In end-to-end settings with entity linking, it also remains stronger than RoG and GNN-RAG on both WikiKG2 and Wikidata variants. Its relevance to unseen entities is practical rather than taxonomic: answering is grounded in a test-time external KG and a neural executor, not in the LLM’s parametric memory of entity facts.

Incomplete-KG settings expose another failure regime. GR-Agent constructs benchmarks by deleting direct answer-supporting triples while preserving inferential alternatives through high-confidence Horn-rule groundings (Zhou et al., 16 Dec 2025). It then treats KGQA as agent-environment interaction over three tools: Relation Path Exploration, Reasoning Path Grounding, and Answer Synthesis. The paper reports that all methods degrade from complete to incomplete KGs and that GR-Agent achieves the highest Hard Hits Rate among training-free methods under incomplete conditions. This does not explicitly target unseen entities, but it directly targets a neighboring case in which entity-specific direct support is absent and answering depends on adaptive multi-hop reasoning.

"Prompting LLMs with Partial Knowledge for Answering Questions with Unseen Entities" is the one paper that directly names the task (Yan et al., 2 Aug 2025). It defines Unseen Entity KGQA as answering $\mathcal{G}$7 over an incomplete KG $\mathcal{G}$8 when the head entity cannot be matched and did not appear in $\mathcal{G}$9, while the relation remains linkable. The method retrieves relation-sharing or type-level partial clues, such as T7, T1*, and T4, to “awaken” parametric knowledge already stored in the LLM. On Mintaka with Llama3.1-70B-Instruct, No RAG yields 66.1 / 75.0 Hits@1/Hits@10, while the proposed T7-and-T1* prompting reaches 71.9 / 83.5. The same paper shows that naive embedding-based retrieval baselines such as DiFaR and QD-DiFaR can substantially underperform the no-RAG baseline in this incomplete-KG regime.

A complementary direction reframes the answer itself as a subgraph. UniRel-R1 defines relation-centric KGQA as predicting a subgraph $\mathcal{G}$0 that connects the seed entities rather than a single answer node (Tang et al., 18 Dec 2025). It uses $\mathcal{G}$1-hop candidate subgraphs, hub-based pruning with $\mathcal{G}$2, and RL reward terms favoring connectivity, low-degree intermediates, and high-IDF relations. Training on DBpedia500 and evaluating directly on other datasets, the paper reports strong cross-dataset transfer and states that the model generalizes effectively to unseen entities and relations. The Original-vs-Modified experiments, where entity and relation labels are replaced by random identifiers, are especially revealing: Qwen models degrade strongly under anonymization, whereas Llama models are substantially more stable, suggesting different balances between semantic-label transfer and graph-structural reasoning.

6. Failure modes, diagnostics, and unresolved directions

The empirical literature isolates three recurring failure modes. The first is entity grounding and candidate recall. GETT-QA’s analysis states that once the correct entities and relations are in the top-k candidate sets, the downstream parser almost always succeeds—“More than 95\% of questions where the correct entities and relations were in the top-6 and top-3 candidates respectively, the right answer was eventually produced”—but only 41\% of questions had the correct entities and relations within those top-k sets (Banerjee et al., 2023). ElNeuQA makes the same point from another angle: moving entity handling out of the decoder sharply increases the fraction of outputs with correct entities, but zero exact accuracy on WikidataQA persists because template generalization remains unresolved (Diomedi et al., 2021).

The second failure mode is hallucination under entity scarcity. CoLoTa shows that answer rates can remain extremely high even when accuracy and factuality collapse (Toroghi et al., 20 Apr 2025). On CoLoTa, OpenAI-o1’s zero-shot answer rate remains 0.97 for QA and 0.99 for claim verification, while accuracy falls to 0.67 and 0.71. The same paper separates factual hallucination from reasoning error using FActScore,

$\mathcal{G}$3

and a step-validity metric over reasoning traces. For OpenAI-o1 on QA, FActScore drops from 0.95 to 0.69 while the reasoning score drops from 1.00 to 0.83; on claim verification, FActScore drops from 0.99 to 0.63 while reasoning drops from 1.00 to 0.88. The implication is that unseen-entity KGQA is not only a retrieval problem: even when support exists in the KG, reasoning quality can degrade once the model leaves familiar head-entity regimes.

The third failure mode is benchmark mismatch. Several benchmark papers explicitly note that they do not provide canonical entity-disjoint train/dev/test protocols, reasoning-disjoint protocols, or strict guarantees that long-tail entities were absent from pretraining corpora (Toroghi et al., 20 Apr 2025, Guo et al., 2024, Toroghi et al., 13 May 2026). This suggests an unresolved methodological gap between strict inductive generalization and practical low-memorization evaluation. A plausible research agenda, consistent with these papers, is to combine five requirements in one evaluation setting: explicit entity-disjoint splits, oracle-subgraph and retrieval-required conditions, qualifier-aware reasoning over hyper-relational facts, calibrated abstention or hallucination control, and commonsense or causal inference beyond executable factoid logical forms. CoLoTa explicitly motivates “retrieval + reasoning + hallucination robustness” under long-tail conditions, and that tripartite formulation remains a concise description of the field’s open core problem (Toroghi et al., 20 Apr 2025).