Best Local LLM for Proofreading and Editing Your Writing

A draft manuscript is among the most sensitive documents a writer or knowledge worker holds before it ships. The reviewer is not in the cc list; the source material is not in the chat; the email thread is not for public consumption. Yet every paragraph pasted into Grammarly, ProWritingAid, ChatGPT, or Claude goes to a vendor’s data centre on the way to a rewrite. Three common hosted options: Grammarly (Pro at US$12/month with full-sentence rewrites), ProWritingAid (Premium at US$10/month on the annual plan, Premium Pro at US$12/month annual; prices as listed in October 2026, and the page may show local currency), and a general-purpose chat assistant like Claude Pro (US$17/month annual or US$20/month monthly). The alternative that does not involve trusting any of them with the manuscript is the same stack this site’s local-AI cluster already covers: a model on your hardware, a front end that knows how to point it at a passage of text, and the discipline to never send the document anywhere by default.

This page walks through what “local proofreading and editing” actually looks like in October 2026, what the model and front-end choices are, and which combinations of model size and interface cover four common editing jobs - spelling and grammar, sentence-level rewriting, paragraph-level tightening, and whole-document style passes.

TL;DR

Local proofreading is two pieces, not one product. A model runner (Ollama or llama.cpp) supplies the weights and inference. A front end that supports selected-text rewriting - for example Open WebUI’s Notes feature - supplies the workflow that turns “highlight this sentence and ask for a rewrite” into an in-place edit of the document.
For grammar, spelling and sentence rewrites, a small local model is a reasonable starting point. Qwen3 8B at the qwen3:8b tag (5.2 GB, 40K context) fits an 8 GB machine. Mistral Small 3.1 24B (mistral-small3.1:24b at 15 GB, Apache 2.0, 128K context) is a larger option for paragraph-level work. No independent proofreading benchmark is cited here; quality claims below are general expectations, not measurements.
For style and tone, larger models are generally the safer choice. The qwen3:14b tag at 9.3 GB and the gemma3:12b tag at 8.2 GB both fit a 16 GB tier. On a 24 GB card, gemma3:27b at 17 GB and mistral-small3.1:24b at 15 GB fit with some room left for context.
The hosted alternatives see your prose, whatever their retention statement. ProWritingAid’s pricing page states “We never keep your work or any text entered into our editor. We run thousands of analysis requests every day. The data is encrypted and sent to our servers to be processed, but it is never stored on these servers.” That statement covers the editor text; it does not address the parent organisation’s logging or any third-party model calls behind the rewrite feature.
If you want zero bytes of your manuscript leaving your machine, the path is Ollama on the host, Open WebUI’s Notes workspace on top, and a model in the 8B-24B range whose licence suits the work.

What “local proofreading” actually means

Four editing jobs cover most AI-assisted writing work:

Spelling and grammar. Catch typos, comma splices, subject-verb agreement, and the small mechanical errors that distract a reader. A 4B-8B model is a reasonable fit for these on plain prose, though it will miss some errors.
Sentence-level rewriting. Highlight a clunky sentence, ask for a rewrite, accept or reject the suggestion. This is the closest analogue to what Grammarly Pro’s full-sentence rewrites do, and it is the workflow Open WebUI’s Notes feature is built around.
Paragraph-level tightening. Rework a paragraph for clarity, change the voice, or make it shorter. This is where the model has to read enough context to keep the surrounding sentences consistent, and 24B-class models start to matter.
Whole-document style pass. Apply a consistent style (more formal, less corporate, shorter sentences) across a full draft. This needs a long context window and a model that can hold the document in mind, which is where the 32K-128K context tags matter (see the context caveat below).

A “local” deployment has to handle all four without sending the document to a third-party LLM. The model has to run on hardware you control. The front end has to know how to point the model at a selected passage rather than dumping the whole document into every chat. Anything that bounces through a vendor API - even if the model is open-weight - breaks the chain.

Models worth pulling

The mainstream open-weight chat models cover all four editing jobs; the question is which one fits which tier. The Ollama tags below were checked against the live library pages in October 2026. Sizes are Ollama’s download sizes in decimal GB (for example, the gemma3:27b layers total 17,413,409,507 bytes, which is 17.4 GB or 16.2 GiB); running the model needs that much memory plus room for the context (KV cache), so leave headroom above the listed size. The context column is the maximum the tag supports; per the Ollama context-length docs, Ollama defaults to 4k context on machines with under 24 GiB of VRAM and 32k at 24-48 GiB, so longer context has to be set explicitly and costs extra memory.

Job	Model	Ollama tag (size)	Context	Licence
8 GB laptop, spelling/grammar	`gemma3:4b`	3.4 GB	128K	gemma (gated)
8 GB laptop, sentence rewrites	`qwen3:8b`	5.2 GB	40K	Apache 2.0
16 GB tier, paragraph tightening	`qwen3:14b`	9.3 GB	40K	Apache 2.0
16 GB tier, style + long context	`gemma3:12b`	8.2 GB	128K	gemma (gated)
24 GB tier, paragraph rewriting	`mistral-small3.1:24b`	15 GB	128K	Apache 2.0
24 GB tier, whole-doc style	`gemma3:27b`	17 GB	128K	gemma (gated)
24-32 GB+ workstation	`qwen3:32b`	20 GB	40K	Apache 2.0

The Qwen3 family, per the Ollama qwen3 page, is “the latest generation of large language models in Qwen series.” Per the Qwen3-8B Hugging Face model card, the 8B variant is 8.2B parameters (6.95B non-embedding), licensed Apache-2.0, with 32,768 tokens of native context and 131,072 tokens with YaRN. The card lists “100+ languages” support and a thinking / non-thinking mode switch that the front end can drive.

The Gemma 3 family, per the Ollama gemma3 page, ships in 270M / 1B / 4B / 12B / 27B sizes; the 4B, 12B and 27B tags have 128K context and the 270M and 1B tags have 32K. The 4B variant per the Hugging Face model card was trained on 4 trillion tokens across web documents, code, mathematics, and images, supports 140+ languages, and is gated behind Google’s Gemma terms. Gemma 3 4B IT also takes image input, which matters if the document to proofread is a screenshot of a page or a scanned page converted to an image.

The Mistral Small 3.1 24B model, per the Hugging Face model card, is 24 billion parameters, 128K tokens of context, and Apache 2.0. Per the Ollama mistral-small3.1 page, the mistral-small3.1:24b tag is 15 GB with 128K context and text and image input. Note that the older mistral-small:24b tag (14 GB, 32K context) is Mistral Small 3, not 3.1. Qwen3 (per its Hugging Face cards) and Mistral Small 3.1 are Apache 2.0; the Gemma line requires accepting Google’s terms; fine-tunes of any of them carry their own licence terms, so check each fine-tune’s own page.

Front ends that fit the editing workflow

The model alone is not enough. The front end is the piece that turns “highlight this sentence, ask for a rewrite” into a real workflow.

Open WebUI - Notes. Per the Open WebUI README, it is “a home for AI, a self-hosted AI platform that’s extensible, feature-rich, user-friendly, and built to run entirely offline.” Per the Notes feature docs, Notes is “a dedicated workspace for content that lives outside of any single conversation: drafts, cheat sheets, research findings, project briefs.” The Notes editor is a good fit for proofreading: a Markdown and rich text editor, a chat sidebar that can rewrite a selected passage in place, and edits that “land in the editor as the model makes them, without a reload.”

The docs describe the rewrite mechanic directly:

“Rewriting happens in the chat, there is no separate Enhance button. Select the passage you want reworked, open the chat and either use the Rewrite the selected text. suggestion or say what you want.”

The note itself is not pasted into the conversation; the chat carries a system prompt with the note’s id, the model reads the note via view_note, and edits it via replace_note_content. Two caveats from the same docs: models that cannot call tools will not see the note content at all, so the model needs tool (function) calling support; and Undo/Redo only walks versions the editor recorded, so a tool edit on a note without such versions cannot be undone there (the previous text remains in the chat’s tool output).

Open WebUI’s licence, per the LICENSE file, includes a branding requirement:

“licensees are strictly prohibited from altering, removing, obscuring, or replacing any ‘Open WebUI’ branding… except in the following circumstances: (i) deployments or distributions where the total number of end users… does not exceed fifty (50) within any rolling thirty (30) day period; (ii) the licensee has obtained specific prior written permission… or (iii) where the licensee has obtained a duly executed enterprise license…”

The clause only restricts changing the branding. A writer or team using the stock interface is unaffected; an organisation with more than 50 users in a 30-day window that wants to rebrand or white-label the editor needs permission or an enterprise licence.

Ollama (no UI). For writers who want the absolute minimum - run a model, paste a passage, get a rewrite - Ollama itself is enough. ollama run qwen3:8b opens a REPL, the writer pastes a paragraph with “Rewrite for clarity:” prepended, and gets a rewrite. No editor, no undo, no selected-text targeting; just a terminal. The upside is that nothing leaves the machine and there is nothing to install beyond Ollama and the chosen tag.

Other options worth knowing. text-generation-webui (oobabooga / TextGen) has a Notebook tab “for free-form text generation outside of chat turns,” which can be used for paragraph rewrites, without Open WebUI’s selected-text targeting. KoboldCpp generates text “in chat, adventure, instruct, or story writing modes”; instruct mode can be used for rewrites, though its bundled tools lean toward fiction and roleplay rather than document editing.

The hosted alternatives

Three hosted products get compared against a local stack. The honest framing is what each does and does not see.

Grammarly. Per the Grammarly plans page, the Free tier includes spelling / grammar corrections and 100 AI prompts per month. The Pro tier is US$12 per month (as listed in October 2026) with full-sentence rewrites, tone adjustment, fluency suggestions, plagiarism and AI-text detection, and 2,000 AI prompts per member per month. The page’s only security language is “Grammarly keeps security at the heart of our product, infrastructure, and company operations” and a reference to a SOC 2 (Type 2) report. The specific retention and training-on-your-text statement is on a separate policy page, not the plans page itself.

ProWritingAid. Per the ProWritingAid pricing page, the Premium tier is US$30 per month or US$10 per month on the annual plan (US$120 per year), with a US$399 lifetime option. Premium Pro is US$36 per month or US$12 per month annual (US$144 per year), with a US$699 lifetime option (prices as listed in October 2026), and is highlighted as the “Best Package.” The page states:

“We never keep your work or any text entered into our editor. We run thousands of analysis requests every day. The data is encrypted and sent to our servers to be processed, but it is never stored on these servers.”

That covers the editor text. It does not, by itself, address parent-organisation logging, abuse-detection systems, or any third-party LLM call that powers the rewrite feature - which is the part that matters for an unpublished manuscript.

Claude Pro (general-purpose assistant). Per the Claude pricing page, the Free tier is $0 with “Free for everyone.” Pro is $17 per month with annual subscription discount ($200 billed up front), or $20 per month billed monthly. Max starts from $100 per month. A writer can paste a paragraph and ask for a rewrite; the paragraph reaches Anthropic’s servers, is processed by the model, and is subject to Anthropic’s data-retention and training policy. The pricing page lists model training as “Opt-out” on the individual plans; retention details are in Anthropic’s policy pages.

The privacy delta is the only honest argument for the local stack. Quality on small hardware is mixed - a frontier hosted model can generally be expected to write more careful rewrites than an 8B local model - but with a hosted tool the manuscript leaves the machine, and with a local model it does not.

What local proofreading does not solve

Three honest limitations.

Spelling-and-grammar reliability on the small tier. A 4B-8B local model will miss some errors that a dedicated grammar checker catches, and no independent benchmark comparing them on proofreading is cited here. Larger models and a clear system prompt (“You are a copy editor. Preserve the author’s voice. Reply only with the corrected text.”) help; reading the output against the original is still necessary.
Long-document coherence. A 50,000-word manuscript is very roughly 65,000-70,000 tokens of English prose. That exceeds the 32K-40K tags outright, and while the 128K tags can in principle hold it, Ollama’s default context on machines under 24 GiB of VRAM is 4k, and raising it costs memory a 16 GB or 24 GB machine may not have after the weights. In practice local style passes are done in chunks, and the writer is responsible for stitching.
House style rules. Grammarly’s plans page lists a “Style guide” feature on paid tiers, and ProWritingAid’s lists a “Custom style guide” to “Add your own rules.” A local model has no such rule store; the writer has to paste the relevant rules into the system prompt each time.

A short decision framework

Five questions, in order:

Are you OK with your manuscript being processed by a vendor LLM? If yes, ProWritingAid or Grammarly is faster to start, and the free tiers of Grammarly and Claude cost nothing to try. If no, the local stack is the only answer.
How much VRAM do you have? 8 GB gets Gemma 3 4B (3.4 GB tag) or Qwen3 8B (5.2 GB tag) and solid sentence-level rewrites. 16 GB gets Qwen3 14B (9.3 GB tag, 40K max context) or Gemma 3 12B (8.2 GB tag, 128K max context) for paragraph-level tightening; usable context is limited by memory left after the weights. 24 GB fits Mistral Small 3.1 24B (15 GB tag) or Gemma 3 27B (17 GB tag) with some room for context. Qwen3 32B at 20 GB fits a 24 GB card with little context headroom; 32 GB or more is more comfortable.
Do you need a rich editor with selected-text rewrites? Open WebUI’s Notes feature does this. If you want a notebook-style free-form generator, text-generation-webui’s Notebook tab works.
Do you want a permissive-licence model? Mistral Small 3.1 24B is Apache 2.0 with no gating. Qwen3 8B, 14B and 32B are Apache 2.0 on their Hugging Face cards. Gemma 3 requires accepting Google’s terms and is gated on Hugging Face. Fine-tunes can change the licence chain, so check each fine-tune’s own page.
Do you want a portable app with no installer? Ollama’s REPL is the simplest; Open WebUI installs via pip, uv or Docker and also has a native desktop app; text-generation-webui has portable builds. The choice is more about the workflow than the install.

For most writers on a laptop with 16 GB of RAM, the practical setup is Ollama running Qwen3 14B (or Gemma 3 12B if you accept the Gemma terms), front-ended by Open WebUI’s Notes feature for the selected-text rewrite loop. A 24 GB card bumps the model to Mistral Small 3.1 24B (Apache 2.0, no gating) or Gemma 3 27B for whole-document style passes. The manuscript stays on the machine. Qwen3 and Mistral Small 3.1 are Apache 2.0, while Gemma 3 is under Google’s own terms.