What Is a Named Entity?

What Is a Named Entity?

A named entity is a real-world object referred to by a proper name in text — a person, organization, location, date, monetary amount, product, or domain-specific concept. Identifying named entities and their types is the job of named entity recognition (NER). Named entities are the anchors LLM systems use to ground answers, redact PII, route queries, and cite sources. In 2026 LLM stacks, entities are tagged automatically by NER models, used as keys in knowledge graphs, and matched in evaluators that score whether retrieved context covers the right entities.

Why It Matters in Production LLM and Agent Systems

Most production LLM bugs are entity bugs. A RAG pipeline answers a question about “Acme Corp” by retrieving chunks about “Acme Industries” — same NER type, different entity. A support agent confidently quotes the wrong order ID. A summarization model drops a CEO’s name and replaces it with a pronoun, breaking downstream parsing. A PII redactor catches “Sarah Patel” but misses “Sarah P.” because its NER model was trained on full names. None of these are “the model is dumb” failures — they are entity-handling failures, and they look different from generic hallucinations.

The pain falls across roles. Backend engineers see citation rates drop and traceability break when entities are summarized away. Compliance teams see PII slip past redaction because the NER model’s recall on minority-language names is low. Product managers see CSAT drop on queries that name lesser-known entities the model has not seen often.

In 2026 agentic stacks, entities sit at the boundary between the LLM and the rest of the system. Tool calls take entity arguments. Knowledge bases are keyed on entities. Audit logs require entity-level redaction. Multi-step traces depend on the same entity appearing consistently across spans. Entity tracking is plumbing — invisible when it works, catastrophic when it does not.

How FutureAGI Handles Named Entities

FutureAGI’s approach is to make entities first-class in evaluation. ContextEntityRecall measures whether the entities the user asked about are present in the retrieved context — a much more precise RAG signal than generic relevance because it directly answers “did we retrieve the right thing for this entity?” The PII evaluator runs an NER-driven detector across inputs and outputs and flags entities that match PII categories (person, email, phone, government ID), with optional redaction handed off to pre-guardrail and post-guardrail stages in the Agent Command Center.

Concretely: a healthcare RAG agent built on traceAI-langchain indexes patient-education documents. For every query, FutureAGI runs ContextEntityRecall to confirm the retrieved chunks actually contain the named entities the user mentioned. When recall drops below 0.7 for a cohort of medication-name queries, the trace view shows the retriever is keying on generic words (“Tylenol”) and missing variant spellings (“acetaminophen”). The team adds a synonym table to the retriever and re-runs ContextEntityRecall against the canonical golden dataset, lifting recall to 0.91. On the PII side, the same agent runs PII as a post-guardrail so any patient name that leaks into a response is redacted before it reaches the user-facing UI.

How to Measure or Detect It

Entity quality is measured at retrieval, generation, and guardrail boundaries:

• ContextEntityRecall: returns the fraction of question entities present in retrieved context.
• PII: detects entities matching PII categories; returns category labels and spans for redaction.
• NER F1 per entity type: the standard benchmark on a labeled dataset; track per-type to catch minority-class drops.
• Entity coverage in citations: the fraction of named entities in the answer that have at least one cited source.
• Entity drift signal (dashboard): when entity recall drops but generic relevance stays flat, the retriever has shifted off the right keys.

Minimal Python:

from fi.evals import ContextEntityRecall

cer = ContextEntityRecall()
result = cer.evaluate(
    input="What dosage of Lisinopril is appropriate for stage I hypertension?",
    context=retrieved_chunks
)
print(result.score, result.reason)

Common Mistakes

• Treating entities as keywords. Two distinct entities can share a surface form (“Apple” company vs. fruit) — type-aware NER matters.
• Skipping coreference. “She” and “the CEO” refer to the same entity; coreference must be resolved before entity-based eval.
• Using English-only NER on multilingual traffic. Recall on non-English names collapses; use multilingual NER models.
• No PII coverage on entity variants. “Sarah Patel” and “Sarah P.” both leak the same person; cover both.
• Ignoring entity drift in retrieval. A retriever can stay relevant globally while losing the entities that matter — measure both.