Beckon

Inspiration

The web stopped being a collection of documents about ten years ago — it's now a collection of apps. But the way we use those apps is still stuck in 1995: scan the page, hunt for the link that matches your intent, click, wait, repeat. Every SaaS tool we touch makes us translate our goal into its menu structure.

We kept asking the same question: why do we have to go find the UI? Why can't the UI come find us?

Two things had to be true at once for the answer to finally be "it can":

LLMs got fast and cheap enough to semantically analyze an entire DOM in the page-load budget. Three years ago this cost a dollar per page. Today it's a fraction of a cent.
Attention is a high-quality input signal — where your cursor lingers, how you scroll, what you re-read — and nobody is using it.

Beckon is what happens when you put those two facts together.

What it does

Beckon is a browser extension that flips the web from "user finds the UI" to "UI finds the user."

When you hover, pause, or linger on anything in any web app, Beckon understands what that element means in the context of the site you're on right now, and generates the right contextual actions around your cursor — no tab switching, no menu hunting, no prompts.

The same gesture produces completely different actions depending on where you are:

LinkedIn — hover a person → Mutual connections / Recent posts / Draft intro. Hover a company → Headcount trend / Recent funding / Open roles.
Yahoo Finance — hover a ticker → 1Y chart / Key metrics / Earnings date. Hover a CEO → Tenure / Insider trades / Last call sentiment.
Gmail — hover a sender → Last 3 threads / Reply owed? / Draft reply in your voice.
GitHub — hover a repo → Star velocity / Contributors you follow. Hover a function → Definition / Recent changes / Top SO answer.

A "name" on LinkedIn is a person. A "name" in GitHub is a function. A "name" in Figma is a component. The action set is completely different — and Beckon generates the right one for each.

The signature UI is a bubble cluster: up to five rounded action bubbles float around your cursor, and the bigger the bubble, the more Beckon thinks you want it. The most likely action sits directly above the cursor; the rest fan out counter-clockwise so they don't block the page content your eye is heading toward next. Each bubble has a number key (1–5) so power users never touch the mouse. And every time you click one, a faint dotted line traces back to where that action would have lived on the original page — turning Beckon from a magic black box into a visible shortcut layer.

There's also a Focus Mode: one toggle dims everything outside ~300px of your cursor, so when you actually need to read, Beckon gets out of the way.

How we built it

Extension shell — Chrome MV3 scaffolded with WXT, vanilla JS for DOM injection plus a small React island for the bubble cluster and preview cards.
Semantic layer — at page load, Beckon quietly hands the DOM to the Claude API and gets back a per-element semantic map: what is this thing on this site, and what would a user plausibly want to do with it? Results are cached in memory so runtime hover is instant.
Generative action layer — when a hover crosses the intent threshold (~500ms or a deliberate pause), Beckon assembles the bubble cluster on the fly: action labels, probability-weighted sizing, and the inline preview content (mini-charts, summaries, code blocks).
Styling — inline CSS with backdrop-filter for the glass-morphism look, so the overlay always reads as layer, not page.
Demo environment — a single-file HTML mock with three switchable sites (LinkedIn / Yahoo Finance / Gmail) so the demo can't be derailed by a real site shipping a redesign mid-pitch.

Challenges we ran into

Intent detection without false positives. Hover is noisy. Tuning the dwell threshold, scroll-velocity gating, and cursor-jitter filtering took most of our debugging time — the bubbles cannot pop up while you're just moving the mouse across the page.
Probability-as-size, without chaos. Letting bubble size encode predicted intent is the core of the visual language, but if the sizes shift every frame the cluster feels unstable. We locked sizes per session and only re-rank between hovers.
Site-aware prompting. Getting Claude to reliably produce site-specific action sets (a person on LinkedIn vs. a person on Yahoo Finance) instead of collapsing to generic "summarize / search / copy" actions required structured prompting and a per-site context primer.
Staying out of the way. The hardest design constraint was philosophical: Beckon has to feel like less UI, not more. Every animation, every pixel of the cluster was scrutinized for whether it earned its place.

Accomplishments that we're proud of

A working prototype that demonstrably produces different action sets for the same gesture across three real-feeling sites — the central thesis of the project is no longer hypothetical.
The bubble cluster as a new visual language: probability-as-size, fixed top anchor, counter-clockwise fan, number-key parity, dotted-line trace-back. We haven't seen any other AI-on-the-web tool commit to a UI primitive this opinionated.
Sub-second perceived latency on hover, because the expensive semantic work happens once at boot, not on every interaction.
A demo that sells the idea in 90 seconds without a single prompt being typed.

What we learned

Attention is a real input modality. Once you start treating cursor dwell and scroll cadence as first-class signals, an enormous amount of UI just... stops needing to exist.
Boot-time AI is underrated. The instinct is to call the model when the user acts. The win is calling it before the user acts, so the action feels like it was always there waiting.
A strong visual primitive beats a strong feature list. When we stopped describing Beckon as "AI actions on hover" and started showing the bubble cluster, every conversation about it changed.
The dotted line matters more than we expected. The single most common reaction in user tests was "oh — that's where that was hiding." Making the saved click visible turned out to be the trust mechanism.

What's next for Beckon

Personalization. Bubble ordering and sizing should learn from each user's history, so the cluster you see at month three is not the cluster a new user sees on day one.
More sites, deeper semantics. Notion, Google Docs, Amazon, arXiv, Bloomberg — each unlocks a new persona (researcher, shopper, analyst).
Cross-site memory. A name you hovered on LinkedIn this morning should be recognized when it shows up in your inbox this afternoon.
An open action SDK. Let any web app declare its own Beckon actions, so the layer grows with the web instead of chasing it.
The long bet: Beckon isn't a plugin. It's an early sketch of the interaction model that finally fits what the web actually is now — a collection of apps, not a collection of documents. We want to build the rest of it.