← Back to R3write

AI transparency

Applies to R3write 1.5.0 · Last updated 13 August 2026 · History on GitHub

1. R3write is an AI system

When you press Ctrl+Alt+G and pick an action, the selected text is sent to a large language model, and what comes back is written by that model. It is not a rules engine, a thesaurus, or a template. There is no human in the loop between your selection and the suggestion on screen.

The app states this where the output appears rather than only here. The quick-edit popup carries a permanent AI-generated · review before use line beneath the rewrite, and Settings → AI names the provider and model currently in use.

What that means for the output

Language models fail in specific, repeatable ways. In a rewriting tool the ones that matter are:

• Invented specifics. Numbers, names, dates and citations that were not in your original can appear in the rewrite, especially with Expand.
• Dropped qualifiers. "usually", "approximately", "in most cases" are exactly the words a shortening pass removes — and exactly the words that carry your liability.
• Shifted meaning. A more confident tone is not the same claim. Tone and Improve can strengthen an assertion you deliberately hedged.
• Silent normalisation. Idiom, dialect, and deliberate stylistic choices get flattened toward the model's default register.

The Diff view exists for this. It shows the rewrite as a word-level diff — green additions, red deletions — so that reviewing is a glance rather than a re-read. Use it on anything that matters.

2. What leaves your machine, and when

There are exactly three paths by which text can leave your computer, and you control which of them are live.

There is no R3write server. Nothing is proxied, mirrored, queued or logged anywhere the author can reach. Requests go from your machine to your provider over your connection with your key, which is stored in Windows Credential Manager and never written to disk in plain text.

There is no telemetry. R3write does not report usage, crashes, feature adoption, or anything else. Nobody, including the author, can see what you rewrote.

Whose terms apply once text arrives

R3write does not train models and does not retain your text beyond the local history file (last 20 rewrites, on your disk, clearable). Once text reaches a provider, that provider's terms govern it — including whether they retain it and whether they may train on it. That is a decision you make when you pick a provider, and it is worth reading their policy rather than assuming.

• Ollama — local runs never leave your machine; Ollama Cloud has its own terms.
• Google Gemini — note that free-tier and paid-tier data handling differ materially.
• OpenAI
• Anthropic
• Groq
• OpenRouter — an aggregator, so an upstream provider's terms may also apply.

3. Autocorrect: which half is AI

Autocorrect has two distinct halves, and conflating them would be the easiest way to mislead you about this feature.

The half that runs constantly is not a language model. It is a SymSpell dictionary of 82,833 entries compiled into the application, matched by edit distance and ranked by corpus frequency weighted for the mechanical shape of the typo. It makes no network request, loads no model, and needs no key. It would work with the network cable pulled.

The half that is a language model is off by default and asks first. Some errors are invisible to a dictionary because the typed word is spelled correctly — form for from, their for there. When Settings → Autocorrect → Ask the model about confusable words is switched on, those specific words, with up to 80 characters of preceding context, are sent to your configured provider. It fires for a short list of known confusables — on the order of one word in a few hundred — and at most once every two seconds.

That check can only suggest. A reply takes 300–2000 ms, by which point your caret has moved, so the result appears in the correction bubble behind an Apply button. The model never changes text on its own, and replies that are not a single word are discarded rather than applied.

What autocorrect refuses to touch

The feature fails closed: when a check cannot answer, that counts as a refusal.

• Password fields — detected by both the Win32 field style and a UI Automation probe. Either signal saying "password" refuses; neither being able to answer also refuses.
• Elevated windows, remote desktop sessions, and IME/CJK composition.
• Browsers and Electron applications, for now — Windows only reports password fields for native text boxes, and Chromium draws its own.
• Any application you have not added to the list. Keystrokes from outside it are not merely left uncorrected; they are not buffered.
• Terminals are permitted but flagged, and are not on the default list. A shell password prompt is not a password field, so nothing can detect it, and Enter runs the line.

Raw keystrokes are never written to disk. The typing buffer is in memory, capped, and cleared on every invalidation. What is logged is the corrections themselves — the before, the after, and the application — with a retention limit you set and a clear button.

4. R3write was built with AI

The application's Rust and TypeScript, this website, its documentation and much of its changelog were written by the author working with AI coding assistants rather than typed from scratch. Design decisions, review and responsibility for what ships are the author's; the keystrokes largely were not.

No law obliges this particular disclosure, and plenty of software you use was built the same way without saying so. It is stated here because a tool that asks you to think about AI transparency in your own writing should not be quiet about its own.

The practical consequence worth knowing: the source is published on GitHub precisely so that this claim is checkable rather than something you have to take on trust.

5. If you publish what R3write rewrites

One transparency duty lands on you rather than on R3write, and it is easy to miss.

Under Article 50(4) of the EU AI Act, text that is AI-generated or AI-manipulated and published to inform the public on a matter of public interest — politics, administration, justice, fundamental rights, security, health, the environment, consumer safety, or economic, financial, scientific and cultural developments — must be labelled as AI-generated by whoever publishes it. The obligation does not apply where a person has genuinely reviewed the text and taken editorial responsibility for it; a spell-check pass does not count as review.

R3write cannot discharge that for you. It happens at the moment you publish, in the medium you publish to. If you are rewriting a press release, a policy note or a health explainer, this is your obligation and not the app's.

6. Marking of AI-generated text

Article 50(2) of the EU AI Act requires providers of generative AI systems to mark synthetic text in a machine-readable format so it is detectable as artificially generated. The Commission's guidelines exempt AI that performs "an assistive function for standard editing" and does not change the substance or meaning of the text.

Applied honestly to R3write, that splits its actions in two:

• Likely exempt — Fix grammar, and the offline autocorrect, which correct typos and grammar without changing what the text says.
• Likely not exempt — Improve, Expand, Shorten, Tone, Prompt and Custom, which are substantive rewrites.

Current status, stated plainly: R3write does not embed a machine-readable marker in the text it pastes back. It writes plain text into whatever application you are in, via the clipboard, and plain text has no metadata channel to carry a marker that survives the paste. The obligation's transitional deadline is 2 December 2026, and the approach is being worked out in the open — if you have a view on how a clipboard-based tool should do this without corrupting the text it pastes, the issue tracker is the place.

7. Known limits of these statements

• R3write can describe its own behaviour. It cannot describe what your chosen provider does with text after it arrives — see section 2.
• The offline dictionary is not a language model, so it cannot use meaning. It corrects teh; it cannot know that form should have been from unless the contextual check is on.
• Autocorrect's refusals are conservative but not a security boundary. Do not treat "it skips password fields" as a reason to type secrets in an app you have added to the list.
• This page describes 1.5.0. Behaviour in older builds may differ; the changelog is the record.

8. Questions

Open an issue at github.com/drknowhow/R3write/issues. If something on this page is wrong or has gone stale, that is a bug and worth reporting as one.

This page is a description of how R3write behaves, written to be useful to the people who use it. It is not legal advice, and it is not a certification of compliance with any particular regulation. If you are deploying R3write in a context with its own AI transparency obligations, check them against your own counsel rather than against this page.