Here is a sentence that will break most computers.
"I went to the bank."
Did you go to a financial institution to withdraw money? Or did you sit down by the bank of a river? Both readings are perfectly valid. As a human, you'd resolve this instantly, probably without even noticing there was ambiguity to resolve. You'd use context, common sense, and everything else you know about the world to pick the right meaning without thinking twice.
For a computer, this is a genuinely hard problem. And it turns out that language is absolutely full of it.
Word sense disambiguation (WSD) is the NLP term for solving this: given a word that could mean multiple things, figure out which meaning the writer actually intended. As a concept, it sits at the heart of what makes language understanding difficult. As a standalone task with its own dedicated pipeline stage, it has a more specific and nuanced role in modern systems, which we'll get into shortly.
Why Language Is So Ambiguous
Before diving into how WSD works, it helps to appreciate just how widespread the problem is.
Most common words in English carry more than one meaning. The word "bank" has over ten distinct senses in major dictionaries. "Run" has over thirty. Even simple words like "bright" (intelligent? luminous? cheerful?) or "cold" (temperature? illness? emotional distance?) carry multiple meanings that shift depending on context.
This is called lexical ambiguity: a single word form with multiple possible meanings. It's not an edge case or a quirk of English. It's a fundamental property of how human language works. Words evolve over time, get borrowed across domains, and accumulate meanings. The result is a vocabulary where almost every high-frequency word is ambiguous to some degree.
There's a related but slightly different phenomenon worth knowing: semantic ambiguity. This is where the ambiguity doesn't come from a single word but from the structure of a phrase or sentence. "I saw the man with the telescope" is semantically ambiguous because the phrase "with the telescope" could modify either "saw" or "the man." Both the word-level and phrase-level forms of ambiguity fall under the broader challenge WSD is designed to address.
What Is Word Sense Disambiguation?
Word sense disambiguation is the task of automatically identifying which sense of a word is being used in a given context.
In the traditional framing, the inputs are a piece of text and a target word within it. The output is a label identifying which meaning the word carries in that specific context. Those labels typically come from a dictionary or lexical resource like WordNet, which organises words into sets of synonyms (called synsets) and defines each sense separately.
For the sentence "The surgeon operated on the patient," a WSD system would correctly identify that "operated" refers to performing surgery, not running a machine or managing a business. For "The technician operated the crane," it would pick the machinery sense. Same word. Different contexts. Different meanings.
It's worth noting that this traditional framing assumes word meaning can be mapped onto a fixed inventory of discrete dictionary senses. That's a useful engineering abstraction, but it's not the only way to think about meaning. Modern NLP often represents meaning as continuous vectors in high-dimensional space rather than selecting from a predefined list of senses. Some researchers view dictionary sense inventories as practical tools for structured tasks rather than fundamental representations of how meaning works. Both views have merit, and understanding the distinction helps you choose the right approach for a given problem.
What makes this genuinely interesting is that humans do it effortlessly and continuously. Every sentence you read contains multiple potentially ambiguous words, and you resolve all of them simultaneously without effort. A computational system has to learn to replicate that, either by selecting from a sense inventory or by building rich contextual representations that capture meaning without explicit labels.
How WSD Systems Work
There are several approaches to word sense disambiguation, and they've evolved significantly over the decades.
The earliest systems were knowledge-based: they used structured resources like WordNet to compare the definitions of candidate senses against the surrounding context. If you're trying to disambiguate "bank" and the surrounding words include "river," "water," and "fish," the riverbank sense scores higher because its definition overlaps more with those words. This approach is interpretable and requires no training data, but it struggles when context is sparse or unusual.
Supervised machine learning approaches treat WSD as a classification problem. Given a word and its surrounding context (the words before and after it), a classifier learns to predict the correct sense from labelled training examples. These methods work well when you have enough annotated data for the specific words you care about, which is often the bottleneck. Building a labelled WSD dataset is slow and expensive because it requires human annotators to read each sentence and select the intended sense.
Neural approaches using contextual word embeddings changed the game significantly. Models like BERT produce a different vector representation of a word depending on the context it appears in. The word "bank" in a sentence about finance gets a different embedding than "bank" in a sentence about rivers, even though the surface form is identical. This means disambiguation happens inside the model's representations rather than through an explicit sense-selection step.
This is the key shift in modern NLP. Transformer models and large language models perform sense disambiguation implicitly, as an emergent property of how they process context, rather than through a dedicated WSD component. When you ask ChatGPT a question containing an ambiguous word, it almost always resolves the ambiguity correctly from context without any explicit disambiguation step. That capability emerged from training on vast amounts of text. There is no separate WSD module running underneath. The disambiguation is baked into the contextual representations the model builds for every word it processes.
This means that in most modern NLP pipelines, you won't find a dedicated WSD stage. The problem hasn't gone away. It's been absorbed.
Lexical Semantics: The Bigger Picture
Word sense disambiguation doesn't exist in isolation. It's part of a broader field called lexical semantics: the study of word meaning and how words relate to each other.
Lexical semantics is interested in questions like: what does it mean for two words to be synonyms? How do words like "dog" and "animal" relate (one is a type of the other)? Why do "hot" and "cold" feel like opposites while "hot" and "warm" feel like a scale?
These relationships between words are encoded in resources like WordNet, a large lexical database where words are organised into synonym sets and connected by semantic relationships: synonymy (same meaning), antonymy (opposite meaning), hypernymy (broader category), and hyponymy (narrower category). "Dog" is a hyponym of "animal." "Animal" is a hypernym of "dog."
Understanding these relationships matters because WSD is not just about picking the right dictionary entry. It's about understanding how word meaning is structured in language. A system that understands that "operated" in a medical context belongs to the same semantic neighbourhood as "surgery," "incision," and "patient" is doing something more interesting than lookup. It's reasoning about meaning.
Where Explicit WSD Still Has a Role
Most modern NLP systems don't include a dedicated WSD stage. But that doesn't mean the problem is solved or that explicit disambiguation is never useful. There are specific settings where it still earns its place, and understanding them helps you know when to reach for it.
In biomedical NLP, the word "discharge" can mean a patient leaving hospital, a fluid emission, or an electrical release. For systems that extract structured information from clinical notes and feed it into downstream databases or alerts, explicit WSD with a domain-specific sense inventory gives teams control and auditability that a black-box language model doesn't. When a decision needs to be explainable and traceable, knowing exactly which sense was assigned and why matters.
In legal document analysis, words like "party," "consideration," and "execution" carry technical legal senses that differ sharply from their everyday meanings. Explicit terminology mapping using legal ontologies and controlled vocabularies is a common pattern in legal NLP, and WSD is the mechanism that connects surface word forms to those structured definitions.
Knowledge graph construction and ontology mapping are probably where explicit WSD remains most actively used in practice. When you're building a structured knowledge base from unstructured text, you need to map entity mentions and relation phrases to specific nodes in a taxonomy. That requires knowing exactly which sense of a word is intended, and the output needs to be a discrete label, not a vector. Contextual embeddings alone don't give you that.
In machine translation, it's worth being accurate about what's changed. Explicit WSD was historically important in rule-based and early statistical translation systems, where the correct translation of a word genuinely depended on resolving its sense first. Modern neural machine translation systems handle disambiguation implicitly through contextual modelling, just as LLMs do, so dedicated WSD modules are not a standard part of current MT pipelines.
The honest summary: explicit WSD survives in specialised settings where you need structured, auditable, ontology-aligned outputs. For general language understanding in most production systems, transformer models and LLMs have absorbed the disambiguation problem into their contextual representations, making a dedicated WSD stage unnecessary.
Language models don't read words. They read words in context, and context is everything.
The State of WSD Today
It's worth stepping back and being clear about where this all stands.
Resolving the meaning of words from context is not optional in language understanding. It's fundamental. Every NLP system that processes real text is dealing with ambiguity constantly, whether it acknowledges it explicitly or not.
What has changed is how that disambiguation happens. Explicit WSD, where a system selects from a fixed sense inventory using rules or a dedicated classifier, was the dominant approach before transformer models arrived. Today it's a specialist tool. Most production NLP systems, from search engines to document classifiers to LLM-powered assistants, perform disambiguation implicitly through the contextual representations learned by transformer models. There is no dedicated WSD stage. The problem is handled as a side effect of how modern models process language.
Explicit WSD survives where structured outputs are required: ontology mapping, knowledge graph construction, terminology alignment in biomedical and legal domains. In those settings, the ability to produce a named, auditable sense label still has genuine value.
For everyone else, understanding WSD is valuable not because you'll necessarily build a WSD system, but because it helps you understand what language models are actually doing and why context matters so deeply to how language works.
What Comes Next
Word sense disambiguation is the point in this series where we move from structure to meaning. We've covered how text is broken into tokens, how words get grammatical labels, and how sentences get mapped into dependency trees. Now we understand how the meaning of individual words gets resolved from context.
The next step is understanding how that meaning gets represented as numbers that computers can actually work with. That leads us to Bag of Words and TF-IDF: the foundational techniques for turning text into numerical representations, and the starting point for almost every classical NLP system ever built.
Learn This at Fondra Labs
This post is part of our NLP Foundations series, where we build up practical AI knowledge one concept at a time, from text processing basics all the way to the systems powering modern AI.
At Fondra Labs, we teach AI from production reality, not hype. Every topic in this series is here because it genuinely matters when you sit down to build something real.
If this was useful, explore the rest of the blog. We cover machine learning, deep learning, NLP, and the practical skills that turn understanding into building.
Frequently Asked Questions
Javier Aguirre
Teaching AI from production reality, not hype.
Build your AI Foundations
Get the free checklist that production engineers use to avoid these common RAG pitfalls.
Get the Free Guide