Query tracking, selection patterns, access frequency learning, and suggestion precomputation—how we built a command palette that adapts to user behavior.
Beyond Static Menus
Traditional command palettes return the same results for the same query. Type "set" and you get Settings, Setup, Set Password—in that order, every time.
But users have patterns. A developer types "set" wanting Settings. An admin types "set" wanting Set Permissions. The same query, different intent. A palette that learns these patterns becomes faster over time.
Three Learning Signals
The system tracks three signals to build a model of user preferences.
Selection frequency captures what you use. If you open Settings ten times more often than Set Password, Settings should rank higher. This is the most obvious signal.
Query-to-selection mapping captures context. When you type "set", you always pick Settings. When you type "perm", you pick Set Permissions. The query itself predicts intent.
Page context captures where you are. On the Users page, permission-related actions are more relevant. On the Dashboard, navigation commands dominate. Location predicts intent.
The Ranking Function
These signals combine into a ranking score. Each item gets a base text-relevance score from the fuzzy matcher. Learning adjustments add or subtract from that base.
Frequency gets logarithmic scaling. The difference between zero uses and one use matters more than the difference between ten and eleven. Without this dampening, heavily-used items would dominate forever.
Query-specific preferences get strong weight. If you've selected the same item for this exact query five times, that's a strong signal. The probability that you want something else is low.
Context boost is proportional. Items frequently used on the current page get elevated, but not so much that they override text relevance.
Recency provides a light touch. Recent selections appear slightly higher, capturing the "I was just looking for this" pattern.
Decay and Forgetting
Without decay, old patterns accumulate indefinitely. Your preferences from a year ago might not reflect today's workflow.
Time-based decay reduces scores gradually. A selection from yesterday weighs more than one from last month. Old patterns fade unless reinforced by new behavior.
This creates a self-correcting system. If your role changes and you need different commands, the old patterns decay while new ones build. The system adapts without explicit retraining.
Empty Query Intelligence
When the user opens the palette without typing, what should appear?
Recent selections address "I was just doing this" workflows. The three most recent items appear first.
Page-specific suggestions address "what can I do here" questions. If users on this page frequently open certain commands, surface those.
Global popularity fills the remaining slots. Items used frequently across all contexts are likely useful now.
This structure means the empty palette is immediately useful. No typing required to access common actions.
Privacy by Design
Learning data never leaves the device. All preferences store locally, encrypted, tied to the browser or app instance.
This isn't just about compliance—it's about trust. Users behave differently when they know their actions are observed and transmitted. Local-only learning removes that concern.
The tradeoff is that preferences don't sync across devices. We accept this limitation. Privacy is more important than convenience.
The Feedback Loop
Adaptive systems create a powerful feedback loop. The more you use them, the better they predict. The better they predict, the more useful they become. The more useful they become, the more you use them.
This virtuous cycle converts a tool into a habit. Users stop consciously thinking about the launcher and start experiencing it as an extension of their working memory. Type a fragment, see the answer.
The best interfaces are invisible. You don't notice them; you just accomplish your goals. Adaptive learning is how command palettes approach that ideal.
The UX Insight
Personalization often means configuration. The user sets preferences, adjusts settings, customizes behavior. This is explicit personalization.
Implicit personalization works differently. The user does nothing special. They just use the system. The system observes and adapts. Preferences emerge from behavior.
Implicit personalization scales where explicit personalization fails. No one wants to configure their command palette. But everyone benefits from a command palette that learns.
The design goal is invisibility. Learning should be unnoticeable. The system just gets better, without the user knowing how or why. That's the experience we aimed for.