Local Gist
Turns a lease, a plan-renewal notice, or a terms update into a plain-language brief — computed on your device, never uploaded anywhere.
LocalGist
Turns a lease, a plan-renewal notice, or a terms update into a plain-language brief — computed on your device, never uploaded anywhere.
Date: 2026-08-24
Form factor: Browser extension (Manifest V3)
Browser surface: toolbar popup, context menu, on-demand content script (chrome.scripting), chrome.storage
Status: Prototype
What it is
LocalGist reads whatever page you're stuck on — an insurance plan-renewal notice, a lease addendum, a terms-of-service update, an HR benefits portal — and turns it into a short brief: a TL;DR, the concrete facts (dates, dollar amounts, requirements), and a "worth a second look" list for the clauses people tend to skim past. It runs the summary through Chrome's built-in on-device model (Gemini Nano, via the LanguageModel API that shipped out of origin trial in Chrome 138), so the page text never leaves the browser.
Why it has to be an extension
The document you need briefed almost never lives on a site you control — it's your insurer's member portal, your landlord's tenant system, your bank's terms page. A website can call the on-device model on its own content, but it can't reach into a tab open on someone else's domain and read what's there. LocalGist's popup asks chrome.scripting to inject content.js into whichever tab is active when you click "Brief this page," which extracts the readable text and hands it to the on-device model running in the popup's own context. That combination — cross-origin page access plus the on-device model — only exists inside the browser process.
Who it serves
Anyone who's clicked "I agree" without reading, then wondered later what they agreed to. The direct version: someone renewing a health plan, signing a lease, or hitting a "we've updated our terms" banner, who wants the three facts that changed without reading four pages of policy language to find them.
Why it could be profitable
The free tier costs nothing to run per brief — the inference happens on the user's own hardware, not on a server LocalGist pays for, which is a real structural advantage over the cloud-AI summarizer extensions competing for the same shelf space. The paid tier ($4/month or $30/year) is what needs a backend LocalGist doesn't have yet: a saved brief vault across all documents you've read, a "re-check and diff" against a URL you briefed before, and a cloud fallback for the minority of devices where Gemini Nano isn't available. Mozilla shut down Fakespot in July 2025 and ReviewMeta went offline in early 2026, which says something about how fragile cloud-dependent browser tools are when the underlying API or funding disappears — an on-device product doesn't have that failure mode. The honest caveat: this is a utility people reach for occasionally, not daily, so the free tier has to be good enough to build the habit before the paid vault has anything to sell.
The demand signal is closer to "people keep getting burned by not reading" than "people are asking for this exact tool." A 2026 survey found 70% of respondents had forgotten to cancel a free trial at least once, and separately 42% of consumers admit they've forgotten about a subscription entirely while still being charged for it — the underlying behavior (agree now, deal with consequences later) is well documented even without a dedicated survey on this exact product category.
How to load it in Chrome
- Open
chrome://extensionsand turn on Developer mode. - Click Load unpacked and select this folder's
extension/directory. - Visit any page with real text on it, click the LG icon in the toolbar, and press Brief this page. On a browser without the on-device model downloaded yet, the popup says so instead of guessing — check
chrome://on-device-internalsto see model status.
How to try the demo
- Open
index.htmlin any modern browser — no server needed, the sample data is embedded inline forfile://compatibility. - Click the LG icon in the mock toolbar, then Brief this page.
The demo always shows the sample brief, since a plain browser tab loading index.html has no on-device model to call — the same fallback path a real install would hit on unsupported hardware. The mock page's insurance notice stands in for whatever content.js would have scraped from a live tab.
Permissions, and why each one
| Permission | Why it's needed |
|---|---|
activeTab |
Grants temporary access to the current tab only when the user clicks the toolbar icon or the context-menu entry — no standing access to any page. |
scripting |
Injects content.js into the active tab on that same user gesture, to extract the readable text. |
contextMenus |
Adds "Brief this page with LocalGist" to the right-click menu, for briefing without opening the popup first. |
storage |
Holds the pending extraction from a context-menu click (chrome.storage.session) and, on the paid tier, the saved brief vault (chrome.storage.local). |
There's no host_permissions entry and no persistent content_scripts block — content.js only ever runs when the user explicitly asks for a brief.
What's in this prototype
- Toolbar popup that extracts the current tab's text, feature-detects the on-device model, and renders a TL;DR, key points, and a flagged "worth a second look" list.
- Context-menu entry that queues an extraction in the background so the brief is ready the next time the popup opens.
- Honest fallback states: a clear message when the on-device model isn't available, and a separate one when the model call itself fails.
- Demo harness with a mock insurance-notice page and the same popup UI, running the same
popup.js. - Paid-tier UI (saved brief vault, upgrade button) is visible but not wired to real checkout or sync — this prototype has no backend.
Roadmap
- Saved brief vault with a lightweight sync backend, so a brief from one device shows up on another.
- Re-check a previously briefed URL and diff it against the saved version, so a quiet ToS edit doesn't slip by.
- A cloud-model fallback for devices that can't run Gemini Nano, gated behind the paid tier since it's the one part of this product with real inference cost.
- Bulk-brief mode for HR and legal teams reviewing many offer letters or vendor contracts at once.
Sources
- Get started with built-in AI | Chrome for Developers — Gemini Nano hardware/OS requirements and the on-device privacy guarantee.
- The Prompt API | Chrome for Developers — the
LanguageModelAPI this extension calls, stable from Chrome 138. - Subscription Fatigue Statistics 2026 | Readless — 70% of people have forgotten to cancel a free trial at least once.
- Eighth Circuit Vacates the FTC's "Click to Cancel" Rule | WilmerHale — federal cancellation-disclosure rule was struck down in July 2025, leaving state auto-renewal laws as the active backstop.
- Fakespot Chrome Extension Alternative | ReviewAI — Fakespot's July 2025 shutdown and ReviewMeta going offline in early 2026, cited for the cloud-dependency risk argument above.
Requirements
LocalGist — Requirements
Goals
- Turn a long page the user is currently viewing into a short, plain-language brief.
- Run the summarization entirely on-device — no page text is ever sent to a server LocalGist controls.
- Make the free tier genuinely useful on its own, since the paid tier depends on a backend this prototype doesn't build.
- Fail honestly: tell the user when the on-device model isn't available instead of silently doing nothing or faking a result.
Primary user
Someone who has just landed on a document they're expected to accept or act on — a plan-renewal notice, a lease addendum, an updated terms page — and doesn't have time to read all of it before a deadline. They want the facts that changed and the clauses worth a second look, in under a minute.
Functional requirements
- FR1: The toolbar popup shows a "Brief this page" button on open.
- FR2: Clicking the button injects
content.jsinto the active tab viachrome.scripting.executeScript, using theactiveTabpermission granted by that click. - FR3:
content.jsextracts the page's main readable text (preferring<article>/<main>, falling back to the highest text-density block), strips script/style/nav/footer content, and caps the result at 12,000 characters. - FR4: The popup feature-detects
LanguageModel/Summarizerand shows a status pill: "On-device model ready," "On-device model not available," or "Demo — sample brief" in the harness. - FR5: When the on-device model is available, the popup calls it with a system prompt requesting a TL;DR, key points, and a "worth a second look" list as structured JSON.
- FR6: If the model call fails or returns unparseable output, the popup shows a fallback message rather than an error state or a blank screen.
- FR7: A right-click context menu entry ("Brief this page with LocalGist") queues an extraction via the service worker, storing the result in
chrome.storage.sessionand setting a badge count; the popup consumes and clears that queued result on next open. - FR8: The popup shows a "Recent briefs" list, read from
chrome.storage.local, which starts empty on a fresh install (the vault itself is a paid-tier feature not implemented here). - FR9: An "Upgrade" button is visible in the footer at all times and shows an explanatory alert when clicked, since no real checkout exists in this prototype.
- FR10: The demo harness renders a mock insurance-notice page and loads the same
popup.html/popup.css/popup.jsthe real extension uses, sourcing page text and the sample brief from inline JSON instead of live extraction. - FR11: The manifest declares no persistent
content_scriptsand nohost_permissions— all page access happens throughactiveTabplus a user gesture. - FR12:
content.jsguards against being injected twice into the same page by caching its result onwindow.
User stories
- As a plan member reading a renewal notice, I want a one-click brief of what's changing, so that I can decide whether to switch tiers before the deadline without reading four pages of policy text.
- As a renter reviewing a lease addendum, I want the concrete new terms pulled out separately from boilerplate, so that I notice a rent increase or a new fee instead of skimming past it.
- As a privacy-conscious user, I want the summarization to happen without any network call, so that a document I don't want uploaded to a third party never leaves my machine.
- As a user on a browser without the on-device model, I want a clear explanation of why briefing isn't working, so that I don't assume the extension is broken.
- As a user who right-clicks instead of opening the popup first, I want the brief to be ready when I do open the popup, so that the two entry points feel like one feature.
Extension surfaces
- Toolbar popup — the primary UI: trigger a brief, view the result, see recent briefs, hit the upgrade CTA.
- Context menu (page context) — an alternate entry point that queues a brief without requiring the popup to be open first.
- On-demand content script (
chrome.scripting, no staticcontent_scriptsentry) — extracts the active tab's readable text only after a user gesture. chrome.storage.session/chrome.storage.local— hold the queued extraction and (on the paid tier, not yet built) the saved brief vault.
Non-functional requirements
- Extraction is capped at 12,000 characters to stay within the on-device model's practical context window.
- No page text or brief output is transmitted off-device by this prototype — the paid-tier cloud fallback described in the README is explicitly out of scope here.
- Permissions are limited to what the code calls; no
<all_urls>or persistent host access. - The popup must render a usable, non-broken state even when
LanguageModel/Summarizerdoesn't exist (older Chrome, unsupported OS, mobile).
Out of scope (for the prototype)
- The saved brief vault, cross-device sync, and "re-check and diff" feature — all require a backend.
- Real payment/checkout for the upgrade path.
- A cloud-model fallback for devices without Gemini Nano.
- Bulk-briefing multiple documents at once.
Open questions
- Should the free tier cap the number of briefs per day, or stay unlimited since inference is local and costs LocalGist nothing?
- If a page changes between visits, should LocalGist detect that automatically (would need periodic re-extraction) or only on explicit re-brief, even on the paid tier?
- Does prompting the on-device model for strict JSON hold up across document types (short terms banners vs. long PDFs rendered in-browser), or does the schema need to loosen for edge cases?