Summarize any text with an AI model that runs in your browser. Articles, contracts, meeting notes - free, and your text never leaves your device.
You have a contract, an incident report, a board memo or a set of meeting notes, and you want the short version. Pasting it into a cloud assistant would answer the question and create a problem: the text leaves your machine, lands on somebody else’s infrastructure, and is now covered by whatever their retention and training policy happens to say this quarter. This tool does the same job with the model running on your own GPU. The text you paste stays in the browser tab.
That claim is checkable. When you click Summarize privately, the page fetches the WebLLM runtime and a set of quantised model weights, loads them into your GPU through WebGPU, and runs inference locally. The only network traffic is the model download — a large, one-time fetch of the weights themselves — and after that the browser caches them. Your document is never part of a request. Open the network panel, paste a paragraph, and watch: tokens stream into the output box with no outbound call carrying your text.
The requirement is WebGPU, and it is a real gate. In practice that means a recent Chrome or Edge, or Safari 18 or later on macOS Sequoia; Firefox support is still landing. Hardware acceleration must also be switched on in the browser — a browser rendering in software has no GPU to hand to the page, and the tool will tell you so and point you at the setting. If your browser cannot supply an adapter, you get a specific explanation rather than a spinner: Brave’s fingerprinting shield blocking GPU access, acceleration disabled, or an older Safari all produce different messages.
The model dropdown is not a hand-written list. The tool reads WebLLM’s live catalogue of prebuilt models, keeps the instruction-tuned chat models needing under roughly 2.2 GB of VRAM, sorts them smallest first, and offers you the six lightest. That keeps the list current as new small models ship, and it keeps every option something a laptop can actually hold. Each entry shows an approximate download size, or the word downloaded if the weights are already cached.
That cache is shared. Model weights are stored per site, so a model you have already downloaded for any of the other in-browser AI tools here loads instantly from cache — the tool checks and preselects an already-downloaded model when it finds one. Switching models in the dropdown drops the loaded engine and loads the new one on your next run.
| Style | What it produces | Best for |
|---|---|---|
| Bullet points | A short list, one idea per line | Skimming a long document for its content |
| One paragraph | A single continuous paragraph | Something you will paste into an email or a ticket |
| TL;DR | Exactly one sentence, capturing the single most important point | A subject line, a Slack summary, deciding whether to read the original |
| Key takeaways | A list weighted towards conclusions, decisions and action items | Meeting notes and reports where the point is what happens next |
Style and length are separate controls. Length has three settings, and they map to a hard cap on how many tokens the model is allowed to generate: short caps at 150, medium at 350, detailed at 600. The cap is a ceiling, not a target — a short input summarised on the detailed setting will still be short. It matters in the other direction: if a summary appears to stop mid-sentence, you have hit the ceiling, and the fix is to move up a length setting rather than to re-run the same one.
Selecting TL;DR disables the length buttons, because that style always asks for exactly one sentence regardless.
There is nothing to configure here and that is deliberate. The tool sends a fixed system instruction telling the model to produce a faithful summary, to add nothing that is not in the text, to skip preambles like “Here is the summary”, and never to ask a follow-up question. Your text is then wrapped between explicit --- TEXT TO SUMMARIZE --- and --- END TEXT --- delimiters with the style and length instruction in front of it. Temperature is fixed low, so repeated runs on the same input land in much the same place.
Those delimiters do real work: they are what keeps a document that itself contains instruction-like sentences from being read as instructions. It is not a security boundary — nothing in a prompt is — but it is the reason a memo containing the phrase “ignore the above” usually still gets summarised rather than obeyed.
The input box needs at least 50 characters before the run button enables, and shows a live word and character count as you type. There is no upper limit enforced, which brings us to the main practical constraint.
Small models have small context windows, and this tool does not chunk, split, or truncate your input — it sends the whole thing. Push a fifty-page contract in and you are past what the model can hold; the run will either fail outright or the model will be working from only part of your document while presenting a confident summary of the whole. Nothing on the page warns you when you cross that line.
The workable pattern for a long document is manual and boring, and it works:
This two-pass approach also gives you something a single-shot summary cannot: an intermediate layer you can check against the source before the second compression throws detail away.
The page says this itself and it is worth repeating rather than softening. The models that fit in a browser tab are around one to three billion parameters, quantised. Summarisation is one of the tasks they handle best — it is largely extractive, the source material is right there in the prompt, and there is little need for world knowledge. But they are not frontier cloud models, and the failure modes are consistent:
None of this makes local summarisation useless; it makes it a first pass. The right mental model is a fast, private reader who tells you what a document is about so you know which parts to read yourself — not a substitute for reading anything that has consequences.
Two separate costs are easy to conflate. The first run of a given model pays a download of the weights, which is the large one and depends entirely on your connection; the progress bar during that phase is reporting the download, not the summary. Every run after that loads from cache in seconds. The second cost is generation, which is governed by your GPU and by how many tokens you asked for — the detailed setting can take several times as long as short on the same text. Output streams token by token, so you can see progress and judge quality before it finishes.
If load or generation is painfully slow, the bottleneck is your hardware rather than the tool, and the /tools/llm-gpu-benchmark page linked from the tool will tell you how your device stacks up for running local models. Closing other GPU-hungry tabs helps more than people expect.
The privacy property is the entire reason to pick this over a cloud summariser, so use it where that property is load-bearing: contracts and legal correspondence under privilege, incident and post-mortem reports before they are public, board and HR material, patient or client notes, code and configuration you cannot paste into a third party’s box, and anything covered by a customer contract that restricts sub-processors. For a public blog post you were going to read anyway, the privacy argument is worth nothing and a cloud model will do a better job.
There is no export button on the output — select the summary text and copy it. And because the run is stateless, nothing is retained between runs: reload the page and the text, the summary and the conversation are simply gone. If what you actually want is a back-and-forth with a local model rather than a one-shot summary of a document you paste, the in-browser chat tool on this site is built for that; this page is deliberately narrower, and does the one job with no conversation to manage.
Every mainstream AI summarizer — ChatGPT, Claude, the "summarize" button in your favorite app — works the same way: your text is uploaded to a server, processed by a large model, and the result is sent back. For most content that is fine. For confidential content, it is a problem: an NDA-bound contract, an internal incident report, unreleased product material, or anything covered by HIPAA or attorney-client privilege should not be uploaded to a third-party AI.
This tool takes a different path. It runs a small but capable language model directly in your browser using WebGPU. Your text is summarized on your own hardware and never transmitted. The first time you use it, the browser downloads the model (cached for next time); after that it works even offline.
The honest tradeoff is capability. In-browser models have a few billion parameters versus the hundreds of billions behind frontier cloud models, so summaries are solid rather than spectacular, and they work best on text up to a few pages. For routine summarization where privacy matters more than the last 10% of polish, that is an excellent trade. When you need maximum quality on non-sensitive text, a cloud model still wins — this tool exists for everything you cannot or should not send to the cloud.
Yes. The AI model runs entirely in your browser using WebGPU — the same technology games use for graphics. Your text is processed locally and never uploaded, not to us and not to any AI provider. This is fundamentally different from ChatGPT, Claude, or any cloud summarizer, all of which send your text to a server. You can confirm it by loading the tool, going offline, and summarizing — it still works once the model is downloaded.
Honest answer: good, not frontier-level. The tool runs small models (1-3 billion parameters) that fit in a browser, versus the hundreds of billions behind ChatGPT or Claude. For straightforward summarization — condensing an article, pulling key points from notes — small models do well. For nuanced analysis of complex or technical documents, a cloud model will be better. The tradeoff you are buying is privacy: nothing leaves your device.
A browser with WebGPU support — Chrome, Edge, or Safari 18+ (Firefox support is in progress) — and a reasonably modern computer. The first time you summarize, the tool downloads a small model (a few hundred MB to ~1 GB) which your browser caches, so subsequent runs are instant. On older or low-powered machines the model runs slowly; our LLM GPU Benchmark tool can tell you how well your hardware handles local models.
Best results come from text up to a few pages (a few thousand words). Small in-browser models have limited context windows, so very long documents may be truncated or lose coherence. For long material, summarize it in sections and then summarize the summaries. The tool shows a word count so you can gauge length.
Privacy and control. If you are summarizing something confidential — a contract under NDA, an internal incident report, medical or legal text, unreleased material — sending it to a cloud AI may violate policy, regulation, or confidentiality. This tool lets you get an AI summary without that exposure. It also works offline once the model is cached, and there is no signup, no API key, and no per-use cost.
Detect and redact personal and sensitive data — emails, SSNs, credit cards, phone numbers, IPs, API keys — from any text or logs before sharing. Runs 100% in your browser; nothing is uploaded.
Count tokens in text for GPT-4, Claude, Llama, and other LLMs. Estimate API costs and optimize prompts for token limits
Speed test your GPU for AI — measure real memory bandwidth and compute with WebGPU, run an actual LLM in your browser, and see predicted speeds for every popular model on your hardware.
Detect your GPU with one click and see which LLMs your computer can actually run — ranked by whether they fit in your VRAM, need CPU offloading, or will not run at all.
Chat with an AI model that runs entirely in your browser — free, no signup, no API key. Pick a model like Llama 3.2 or Qwen 2.5, or load your own GGUF file. Conversations never leave your device and it works offline once the model is downloaded.