The label is not the job
Traditional conversational systems often begin with a classifier: take an utterance, assign one label, and select a scripted flow. Large language models make that pattern feel outdated because they can infer goals from richer context and produce useful responses without a rigid taxonomy.
But the underlying engineering need has not disappeared. A production system still needs to decide what should happen next, what context is relevant, and which capabilities may be used safely. Intent recognition is evolving from a narrow label into a compact execution plan.
A better output contract
An intent layer should return structured evidence that downstream components can inspect. A practical shape might look like this:
type AnalysisResult = {
intents: Array<{ name: string; confidence: number }>;
entities: Array<{ type: string; value: string }>;
routes: Array<{ target: string; reason: string }>;
};This contract makes uncertainty visible. It also supports multi-intent requests such as asking for tomorrow's weather and creating a reminder in one sentence.
Where rules still win
Rules are useful when decisions are high precision, easy to explain, and relatively stable. They are fast, deterministic, and cheap to test. An LLM becomes valuable when the language is varied, the taxonomy is open-ended, or the decision depends on long context.
- Use rules for explicit commands and safety gates.
- Use embeddings for semantic similarity over a stable route catalog.
- Use an LLM for nuanced decomposition and ambiguous language.
- Use a hybrid path when reliability matters more than architectural purity.
The real design question
The useful question is no longer “do we need intent classification?” It is “what is the smallest reliable decision layer between a user's language and system execution?” Sometimes that layer is a rule. Sometimes it is a model. Good AI engineering makes the choice observable and replaceable.