Browser Extension — Use Cases

A living catalog of what the Nova browser extension can do — chat on any page, element pick, SDLC modes, the browser tool catalog, agent-where-you-work plays, cross-agent runtime, and the security model. Each use case carries an honest Live / In progress / Planned status.

The Nova browser extension puts a Nova agent wherever you already are in the browser. It opens Nova chat in a side panel (Chrome) / sidebar (Firefox), embedding the real Nova /embed/chat route so login, composer, messages, model controls, and voice are owned by the Nova admin app — not a separate extension UI. On top of that it adds browser-native context capture (element picker, React component capture), URL-based agent routing, and optional page context, and — as the Browser Tools work lands — the ability for agents to read, act on, and edit any live website in your authenticated session.

This page is the catalog of those use cases. It is meant to be a living document: as each feature ships and is verified, flip its status badge and fill in the exact @nova prompt + test steps.

How to read this page

Each use case lists (a) what it does, (b) how to trigger it (an example prompt or action), and (c) a status:

Badge	Meaning
`Live`	Shipped and verified in production. Safe to rely on.
`In progress`	Being built — partially landed or behind a flag; not yet verified end-to-end.
`Planned`	Designed (see the Browser Tools design spec) but not yet started.

The @nova prompts and exact test steps below are placeholders to be filled in per feature as it ships and verifies. Where a prompt reads "(prompt TBD)", the feature is not yet Live — do not treat it as a working command yet. Status badges are intended to be flipped here as the build waves complete.

Core — chat on any page

The foundation: the extension panel and the context it captures. This is what's shipped today.

Use case	What it does	How to trigger	Status
Chat on any page	Opens Nova chat in the side panel, embedding the real `/embed/chat` route in an iframe with full login, composer, model controls, and voice. The active tab's URL can route to a specific agent.	Click the Nova Agent toolbar icon to open the panel; type in the embedded chat.	`Live`
Element pick → ask / edit	Click Pick element to capture a DOM + React snapshot of any element (selector, attributes, text, trimmed HTML, bounding box, nearest React components) and stage it as context in the chat.	Click Pick element, click the target on the page, then ask (e.g. "what does this component do?").	`Live`
Page context	Toggles auto-context from the active tab into the chat — best-effort, site-specific extraction for Gmail, Linear, GitHub PRs, and a generic fallback.	Turn Page context on in the panel, then chat about the current page.	`Live`
URL → agent routing	Routing rules resolve which agent answers based on the active tab's URL; the panel injects the resolved agent unless you pin a manual override.	Configure routing rules in Settings; switch tabs and watch the agent switch.	`Live`

SDLC modes — the extension across the software factory

Each phase is a thin mode preset: capture live context on the current page → route to an existing Nova agent. Designer/Design routing is the anchor case and is live today; the others ride on the Browser Tools runtime as it lands.

Mode	What it does	Routes to	Example trigger	Status
Ideation	Clip any site, competitor, or component → "spec / reimagine a Nova version".	Ideation / spec agent → designer	"(prompt TBD) reimagine this landing page as a Nova site"	`Planned`
Spec	Capture a Linear / GitHub / support thread or any page → write the spec back.	spec-issue skill	"(prompt TBD) turn this thread into a spec issue"	`Planned`
Design	Live-edit `example.com/designer` — "make this button red", "change the font", "make it minimal", "add a pricing section" — persisted to the artifact with live preview; or pick an element on any live site to recreate / restyle.	prototyper / designer	"make this button red" on the designer surface	`Live` (designer routing) / `In progress` (recreate-from-any-site)
Code	Pick a broken element on prod / staging → "fix this" with live DOM + React context → opens a PR.	error-fixer	"(prompt TBD) fix this broken button"	`Planned`
QA	The testing companion (below) records a run and feeds the QA engine.	#nova-qa + bug-issue	"(prompt TBD) record a QA run of this flow"	`In progress`
Marketing	Shipped feature → "blog post / social assets"; logged-in analytics → campaign ideas; SEO audit a live page.	#nova-blog / directories	"(prompt TBD) draft a blog post about this feature"	`Planned`

The unifier: one extension, every phase — summon the right agent with full live context on any page.

Tools — the browser tool catalog

The unified Browser toolset agents use to read, act on, and edit a live page. The same tool surface runs in two runtimes — the extension (your real authed browser, in-place) or headless (server-side agent-browser / Stagehand / Browserbase). The agent or flow picks the runtime. The catalog mirrors Playwright-MCP / BrowserMCP / browser-use so it isn't a half-set.

Category	Tools	What it does	Status
Read	`snapshot` (accessibility tree, primary), `read_page` (DOM + React internals), `extract_structured` (scrape → JSON), `get_text`, `screenshot`, `console`, `network`, `list_tabs`, `get_active_tab`	Observe the page — token-efficient accessibility snapshot first, with DOM, structured scrape, and diagnostics as needed.	`In progress`
Act	`click`, `fill`, `type`, `press_key`, `select_option`, `hover`, `scroll`, `find` / `scroll_to_text`, `drag`, `navigate`, `go_back`, `wait_for`, `file_upload`, `download`, `handle_dialog`, tab `open` / `switch` / `close`	Drive the page the way a user would — clicks, typing, navigation, forms, tabs.	`In progress`
DOM-mutate	`set_style`, `set_text`, `set_attribute`, `add_class`, `insert_html`, `remove`, `replace`	Edit the page. On a Nova-owned artifact (the designer) edits persist via the artifact primitives; on an arbitrary site they apply ephemerally (your local tweak).	`In progress`
Evaluate	`evaluate`	Run JS in the page. Gated behind per-domain permission.	`Planned`
Extract	`extract_structured`, `get_text`, `screenshot`	Pull structured data, text, or visuals off a page for downstream use.	`In progress`
Session (high-risk)	`session_fetch`	Use the logged-in session in-place to call a site's API. No raw cookie / token exfiltration to the server. Gated.	`Planned`

Where humans work — agents in your tools

The extension is the agent's presence wherever you already are. These productivity plays ride on the same Browser runtime + the registered-connection.

Use case	What it does	How to trigger	Status
Meeting companion	Capture tab audio (Google Meet / web Zoom / Slack huddle) → transcribe → live notes + summary + action items → Linear / docs / library. Optional real-time "@nova what did we just decide?".	"(prompt TBD) take notes on this meeting"	`Planned`
Save to Nova (clipper)	Save any page, selection, or screenshot to `/library/artifacts` to feed ideation and any agent later.	"(prompt TBD) save this to Nova"	`Planned`
Inbox companion (Gmail)	Triage, draft replies, file to support, create tasks — in place in Gmail.	"(prompt TBD) triage my inbox"	`Planned`
In-context overlays	Summon a Nova agent that acts in place inside Slack / Linear / Notion / GitHub web.	"(prompt TBD)"	`Planned`
Voice on any page	Talk to Nova about the current page (ties to the voice loop / Realtime).	Use the voice / mic control in the panel about the current page.	`In progress`
Region OCR / vision	Grab a screen region → ask about charts, images, or PDFs.	"(prompt TBD) what does this chart show?"	`Planned`
Form autofill from memory	Fill any form from your Nova data / memories.	"(prompt TBD) fill this form"	`Planned`
Selection actions	Highlight text anywhere → summarize / translate / → task / → spec / → blog.	Select text on the page, pick an action.	`Planned`
Real-time presence / triage	A badge surfacing pending approvals + agent results where you already are.	Passive — surfaces in the panel.	`Planned`

Testing & capture companions

Confirmed build items that ride on the same runtime:

Use case	What it does	How to trigger	Status
Testing companion (bug-bash QA)	Renders a test-case app inside the panel; highlights what's about to happen, records the step sequence, captures DOM + console + network + screenshots, and emits a replayable QA run → feeds #nova-qa / files issues.	"(prompt TBD) start a QA run"	`In progress`
Session-recorder → flow / skill	Record a manual browser workflow once → auto-generate reusable browser-tool nodes in a flow (a recorded sequence becomes automation).	"(prompt TBD) record this workflow as a flow"	`Planned`
Capture → repro bug	One click bundles DOM + console + network + screenshot + React state → files a Linear bug with a perfect repro.	"(prompt TBD) file a bug for this"	`Planned`
Before / after PR screenshots	Capture visual diffs of an edit → append to the PR / post to #nova-engineering.	Part of the designer / edit flow.	`Live`
Inspect & explain	Hover any element → the agent explains the component, props, and data source.	Pick / hover an element, ask "explain this".	`In progress`
a11y / perf audit	Run an accessibility + Core-Web-Vitals scan on the current page → report.	"(prompt TBD) audit this page's performance"	`Planned`

Cross-agent — other agents using your browser

When the extension is online it registers your browser as an available runtime. Any of your own agents — web, Slack, Linear, or cron — that have been granted the Browser toolset can then drive your browser in-place.

Use case	What it does	How to trigger	Status
Registered browser runtime	The extension holds a persistent connection registering your browser as an online runtime; agents granted the Browser toolset invoke browser tools when it's online. Offline → the tool returns "browser not connected".	Grant the Browser toolset on `/agents/[id]`; keep the panel open so the browser is online.	`Planned`

Owner-scoped: only your own agents / workspace — never cross-user.
Online-gated: tools only run while your extension is connected.
In-place: tokens stay in the browser; the server never receives raw cookies or tokens.

Security — how this stays safe

Browser-use is a CVE-heavy space (ShadowPrompt, ClaudeBleed), so the security model is first-class. A short user-facing summary:

Protection	What it means for you
Per-domain permission	The agent asks before acting on or running JS against a new domain — you grant access per site. Sensitive categories (banking / finance / crypto / adult / health) are blocked by default and need an explicit override.
Injection guard	All untrusted page content (scrapes, page context) passes through a prompt-injection guard before the agent acts on it, defending against malicious pages trying to hijack the agent.
HITL on consequential actions	Irreversible or sensitive actions pause for your approval, and a takeover mode lets you type passwords / payment details — never the agent.
In-place, no token exfiltration	The agent acts inside your logged-in session; raw cookies and tokens are never sent to the server. Every action is audit-logged. Non-interactive triggers (cron / Slack) are extra-restricted (allowlist + rate-limit, no unattended destructive actions on third-party sites).

References

Design spec: Browser Tools — Design Spec (.claude/docs/2026-06-22-browser-tools-design.md) — the full use-case set, tool catalog, runtimes, security model, and build waves this page tracks.
Extension internals: apps/extension/README.md — panel architecture, auth / iframe lifecycle, context capture, and build / load-unpacked steps.
Related concepts: Agents, Flows, Sandboxes, Integrations.

Browser Extension — Use Cases

On this page