Docs. How to set up reright and how it works.

Your agent sends reright the text it writes for people. reright gives it back so it sounds like you wrote it, and the agent uses that text. The more you correct rewrites and the more of your own writing you bring in, the closer it gets to how you write. If you want to see each rewrite before it is used, turn on "Check before it's used".

Setup

Create an account at app.reright.it with Google or an email address. If you use an email address, confirm it from the link we send. Until you do, reright rewrites and counts nothing, and your agent gets an error that points to Settings. Both ways to connect start in Settings, under Connect. For Claude.ai and ChatGPT, copy the connector address and follow Connect from the cloud. For Claude Code:

Open Settings and select Generate a setup code. The code works once, for ten minutes.
Paste the line that appears into Claude Code. It fetches app.reright.it/setup.md and runs the installer. You can also run reright install --code CODE yourself in a terminal.

The installer sets up Claude Code at user level. It adds the hook, registers the MCP server and adds the rules text to ~/.claude/CLAUDE.md. If an earlier version of reright installed git hooks, it removes them.

The reright and reright-hook programs are open source, and the source is at github.com/interpt-co/reright-cli. The setup line downloads them from that repository's releases and checks the download against a published checksum before it installs anything. You can read the code, or rebuild a release and compare, before you run it.

The installer exchanges the code for a token that belongs to that device, downloads reright-hook and checks its signature and checksum against a key built into reright, and backs up each file before it changes it. It ends with a test rewrite. If "Check before it's used" is on, you approve it in the browser. It writes only files in your home directory, never files in a repository, because an agent can edit those.

Run reright doctor to check each step. Run reright uninstall to put the files back. If you edited a file after the install, only reright's entries are removed and your edits stay. A code that was already used or has expired is refused, so generate a new one in Settings.

Rewriting sends your text to Modal in the US, so you accept that once, with the terms, when you sign up. reright starts the rewriter when you sign up and when you connect an app, so your first rewrite waits less.

Your writing

reright starts from text you already wrote. On the Your writing page you can bring in the mail you sent, exported with Google Takeout, your commits, pull requests and comments on GitHub, your Google Docs, and files you upload: PDF, Word, OpenDocument, RTF, plain text or Markdown. Uploaded files are deleted once their text has been read, and samples that look AI-written are left out. You can delete the samples from any source at any time.

It also learns from your edits. When you change a rewrite before it is used, reright keeps your version. A greeting, sign-off or phrase you keep putting back is then left as you wrote it, as described under Using it. Turning on "Check before it's used" for a while is the fastest way to teach it, because you see every rewrite.

On Pro and Unlimited, reright trains a personal model on your samples and edits, one for each language you write in. Training starts once it has enough of your writing in a language, and each run trains one language, starting with the one reright rewrites most for you. Pro includes 4 runs a month and Unlimited 15. reright switches to a new model only when it tests better than the one you use now. Free and Starter do not train a personal model.

Delete all my writing, on the same page, deletes your samples, your edits and anything learned from them, and you cannot undo it.

Using it

The MCP server has three tools.

rewrite takes the text, a kind, a target such as a repository and branch or a recipient, a line of context, an agent and a run that group your history, and optionally a template, a diff and an origin. It returns an id, the status and, when the status is approved, the text to use as final_text.
rewrite_result takes the id of a pending rewrite and waits for the result.
keep_original takes the id, a category (fact, name, number, date, negation, promise or other) and the exact phrase from each version that changed. The agent calls it only when a rewrite changed a fact, a name, a number, a date, a yes or no or a promise, or reversed the meaning, and gets its own text back. Wording, tone or style is not a reason, and reright refuses a call whose quotes are not in the two texts. It also refuses a quote that is only filler reright took out. It works only for a rewrite nobody checked. When you checked or edited the text, your version stands.

Only free text, the words a person writes, goes to rewrite. Links, numbers, versions, ids, file and branch names, names and code are used as they are. When the words go into fixed text, such as a PR or issue template, a form or a signature, the agent sends just its words as text and the whole template as template, with {{text}} where the words go. reright rewrites the words and returns the filled template.

The kinds are email, message (chat, replies, direct messages), post (anything public), document, code (commits, PRs, issues, code comments) and other. Where the text goes belongs in the target, and why it was written in the context. For an email, a commit or a PR, the first line is the subject or title, then a blank line, then the body, and the review page shows each part in its own box.

Before the rewrite, reright takes out filler: openers such as "I hope this email finds you well", empty offers such as "Feel free to reach out if you have any questions", chatbot closers, and summary lines that only repeat the text. Facts, asks, names, dates and your own greeting and sign-off stay. Each rewrite lists what came out. English gets the most of this, and Portuguese, Spanish, German and French get only the clearest phrases. To keep filler, turn off Remove filler in Settings, under Rewriting.

reright checks every rewrite against the agent's text. The numbers, names, links and code have to match, each paragraph has to stay in its language and the length has to stay close. A rewrite that adds a grammar mistake the agent's text did not have, or adds or drops a "not", is not used. Dates and times keep the word that ties them, so "by Friday" does not become "before Friday", and in English so do bounds on numbers, such as "over" or "at least". Currency signs and signs such as % have to stay. In English documents, every sentence of the agent's text is checked against the rewrite. If a check fails, the agent gets its own text back with a note saying why. Text in a language reright does not support is left as it is. The agent also gets its own text back when the rewrite takes longer than a minute, which can happen when reright has been idle for a while.

Some parts of a text never go to the model, so they come back exactly as the agent wrote them. These are the greeting and the sign-off of an email or a message, text in quotation marks of three words or more, quoted reply lines that start with >, links, email addresses, @handles, hashtags, issue numbers, code, template slots such as [Your Name], and the label at the start of a title, such as fix(web): in a commit or Subject: in an email. A text with headings, bold labels or a list is rewritten one paragraph at a time, so the headings and labels stay as they are. If a word the agent capitalized in the middle of a sentence, such as a name or a weekday, comes back in lower case, reright puts the capital back. A number the agent spelled out, such as "two" or "third", has to stay in the rewrite, as a word or in digits.

The subject of an email and the title of a commit come back as the agent wrote them. Accents the rewrite drops are put back. In English, when the rewrite swaps a single word for one that shifts the meaning, reright puts the agent's word back.

If the rewrite changes a number, a date or a name and nothing around it changed, reright puts yours back and keeps the rest of the rewrite. Numbers also keep the way you wrote them, such as "$30 billion" or "3,5", and "first" stays in phrases like "its first year". The rewrite keeps the way you address the reader: tu or você, du or Sie, tú or usted, tu or vous. When you keep putting the same greeting, sign-off or phrase back after rewrites you checked, reright leaves it as you wrote it in that kind of text. Recent edits count more than old ones, and when you start keeping the change, the lock lifts by itself. Now and then reright still tries the change in a rewrite you check first, so it can notice. You can see these under Your writing and remove any of them.

The agent uses final_text exactly, character for character, since you installed reright for the rewrite. It calls keep_original and uses its own text only when the rewrite changed a fact, a name, a number, a date, a yes or no or a promise, and it quotes the phrase from each version. Different wording, tone or style is not a reason.

Check before it's used

This switch is in Settings, under Rewriting, and it is off by default. When it is on, each rewrite waits in Rewrites until you approve, edit or reject it, and rewrite returns the status pending with a review link. The agent gives you the link once and calls rewrite_result until you decide. What you approve is exactly the text in the editor, character for character. If you reject, the agent is told to stop and wait for your instructions.

Reviewing

Open the link from the notification or from Rewrites. Edit the text if you want to, then decide. You can switch to the agent's text or show the changes before you decide. The oldest waiting rewrite is shown first, and after each decision the next one loads with focus in the editor.

Keys	Action
`Ctrl`+`Enter`	Approve
`Ctrl`+`Shift`+`Enter`	Reject, with the reason field focused
`Esc`	Back to Rewrites
`Alt`+`Down` and `Alt`+`Up`	Next and previous waiting rewrite
`?`	Show the shortcuts

Notifications

When "Check before it's used" is on, turn on push in Settings for each browser or phone you use. A push message names the kind of text and its target. You can add the first line of the text to push messages, which are encrypted for your device.

On an iPhone or iPad, push only works once reright is on the Home Screen. Open the app in Safari, tap Share, choose Add to Home Screen, open reright from its icon and turn on push there.

Claude.ai and ChatGPT

Claude.ai, Claude Desktop and ChatGPT connect with the connector address from Settings.

Server URL: https://app.reright.it/mcp
Sign in: OAuth 2.1 with your reright account, which the client handles when you add the URL.

Connect from the cloud has the steps for each one and the instructions to add to a project. A connector has no hook, so nothing blocks text the assistant sends without calling reright.

Client	How it connects	Blocks text by hook
Claude Code	The line from Settings runs the installer	Yes
Claude.ai and Claude Desktop	A custom connector, added by you	No, only the instructions
ChatGPT	A connector in developer mode, added by you	No, only the instructions

Rules text

The installer writes this text into ~/.claude/CLAUDE.md. For a Claude Project or ChatGPT, use the shorter version on Connect from the cloud.

<!-- reright:start -->
## reright: rewrite text other people read

Before you use any text, ask yourself: will anyone besides the user read it?

- Yes: emails, messages to other people, posts, PR, issue and review text, comments on shared platforms, documents sent to or shared with others, drafts the user will send to others, and commit messages in repos other people work in or read. Call the reright tool `rewrite` first.
- No: your replies to the user, notes, plans and docs for the user's own use, code comments, internal tools, scratch files, config, logs, and commit messages in a repo only the user works on. Skip reright.
- Not sure: ask the user once rather than guessing. If you can't tell whether a repo is shared, commit as usual: the hook blocks the commit in a shared repo, and then you send the message through `rewrite`.

Call `rewrite` with the text, its `kind` (`email`, `message`, `post`, `document`, `code` or `other`), where it goes (`target`) and a line of `context`. For an email, a commit or a PR, the first line is the subject or title, then a blank line, then the body.

Send only free text, the words a person writes. Text with nothing to rewrite, such as a URL, a number, a version, an id, a file or branch name, a name or code, is used as it is without calling `rewrite`. When the words go into a template (a PR or issue template, a form, a fixed footer or signature), put just those words in `text` and the whole template in `template`, with `{{text}}` where the words go. reright rewrites the words and returns the filled template.

If the status is `pending`, call `rewrite_result` with the `id` until it is not. If it is `rejected`, stop and tell the user. When it is `approved`, use `final_text` exactly, character for character, and never edit it yourself. The user installed reright for this rewrite, because your own text sounds like AI. Call `keep_original` only when the rewrite changed a fact, a name, a number, a date, a yes or no or a promise, or reversed the meaning, and quote the phrase from your text and the phrase that replaced it. Different wording, tone, sentence order or style is not a reason.

Hooks block Gmail sends, `gh` PR, issue and release text, and commit and tag messages in shared repos when the text did not come back from reright. A repo counts as shared when it has a remote on a hosting service and either commits by other people in its recent history or a public remote. The user can decide for a repo with `git config reright.commits always` or `never`.
<!-- reright:end -->

A rules text is a request. An agent or client that ignores it can send text that never went through reright, and reright will not know. The next sections explain what the hook does and what gets past it.

How the hook works

reright-hook is a small program that Claude Code runs at four points. Each one reads the hook input from Claude Code on standard input.

pre runs before every tool call. It looks for outgoing text: the message of a git commit or git tag in a shared repository, the title and body of gh PR, issue and release commands, text fields in gh api calls, and Gmail sends, drafts, replies and forwards. It hashes each text with SHA-256 and asks the server whether that text came back from reright in the last 24 hours. If not, the call is denied and Claude is told to send the text to rewrite.
post runs after rewrite and rewrite_result. It records a pending rewrite. If the result is a rejection, it writes a lock file for that session, and pre then denies every tool call in the session.
prompt runs when you send a message to Claude. It removes the session lock, so a reject holds until you type something.
stop keeps Claude from stopping while a rewrite it started is still pending.

For commits, PRs and emails, the full text, the title alone and the body alone are all recorded when the text comes back. That lets gh pr edit --title pass when the title is part of a text that came back from reright.

The hook blocks a call when it can see that text is there but cannot read it, for example a commit message built from a variable, or git commit without a message, which would open an editor. It also blocks when it cannot reach the server. Two environment variables change that on your own machine: RERIGHT_OFFLINE=allow lets text through when the server is unreachable, and RERIGHT_BYPASS=1 skips the text checks. A reject lock still holds when bypass is on. RERIGHT_BYPASS=1 only works when it is set in the environment the agent starts the hook from. Typing it in front of one command does nothing.

Which repositories count as shared

The hook checks commit and tag messages only in a repository that other people read. A repository counts as shared when it has a remote on a hosting service, meaning any remote that is not a path on this machine, and one of these is true:

a commit among the last 200 on any branch was written by someone other than you
the remote is public on GitHub or GitLab

A shallow clone with such a remote also counts as shared, because the history that would show other authors is missing. Any other repository, such as one with no remote or one where every recent commit is yours and the remote is private, is yours alone, and its commit messages go through without a check.

You are every user.email in your git config and any address you add with git config --global --add reright.email [email protected]. A GitHub noreply address counts as you only when its login is the account the gh command is signed in to, or when you list a noreply address with that login in reright.email. Without gh, a noreply address counts as someone else. Commits by bots, with [bot] in the address, don't count. To decide for one repository yourself, run git config reright.commits always or never in it. The default is auto. With --global it sets the default for every repository.

To tell whether a remote is public, the hook asks the GitHub or GitLab API without credentials and keeps the answer for a day. If it gets no answer, it treats the repository as shared. When the hook blocks a commit, its message says why the repository counts as shared.

Turning checks off and on

Sometimes the check gets in the way. You can switch checks off for one kind of text and switch them on again later. The change applies to running sessions at once.

reright status
reright disable commit --for 2h
reright disable commit --here
reright enable commit

The kinds are commit (git commit and tag messages in shared repositories), gh (GitHub CLI text), email (Gmail) and all. With --for the checks come back on by themselves after that time. With --here, or --dir and a path, they are off only inside that directory. A reject lock still blocks while a kind is off, and reright doctor warns while anything is switched off.

Only you can change this. The hook refuses a shell command from an agent that runs reright disable or reright enable, that touches ~/.config/reright/enforcement.json, or that sets reright.commits or reright.email with git config. Run the command in your own terminal, or in Claude Code with the ! prefix. An agent with a file-editing tool, rather than a shell, could still edit that file or a repository's .git/config, because the hook only sees shell and MCP calls.

Enforcement and its limits

reright is not a sandbox. The hook and the rules text both have gaps.

The Claude Code hook

The hook blocks git commits and tags in shared repositories, gh PR, issue and release text, and Gmail sends unless that exact text came back from reright.

We have not checked whether the hook still runs with --dangerously-skip-permissions.
The hook runs on your computer and you control it. Anyone with access to your settings can remove it, turn it off in Claude Code, or set RERIGHT_BYPASS=1. RERIGHT_OFFLINE=allow lets text through when the server is unreachable.
The hook only inspects the tool calls it understands. It reads shell wrappers such as env, sudo and timeout. It lets through text that reaches git or gh through another program: a script run by bash, python or node, bash -c, eval, xargs, find -exec or a git alias. It also lets through curl and wget, mail commands, the browser tools and any MCP tool it does not know.
Commits you make in your own terminal, in an IDE or in the GitHub web editor never reach the hook.
The check compares hashes. It proves the text came back from reright, not that it goes to the target you had in mind.

Claude.ai, ChatGPT and other clients

Chat assistants get the MCP tools and the instructions you give them, with no hook. The client decides whether to follow the instructions, and nothing forces one that ignores them. This includes Claude.ai, Claude Desktop, ChatGPT and Claude Code on the web. They run on the provider's servers, so the hook on your machine does not reach them. Connect from the cloud shows how to add reright there.

Unattended agents work while "Check before it's used" is off, because the rewrite comes back without anyone waiting on it. With it on, every rewrite waits for you.

Quota

Each rewrite call counts the words in its text against the current calendar month (UTC). The template and the rewrite do not count. A word is a run of letters or digits, and an apostrophe, a hyphen or a separator between digits stays inside it, so "don't", "e-mail" and "1,000" are one word each. In Chinese and Japanese, every two characters count as one word, rounded up. Punctuation and emoji count nothing. Text with nothing to rewrite, such as a link or a version, comes back at once and does not count. A text that comes back unchanged because the rewrite failed does not count either: after a timeout, an error, a language reright does not rewrite yet, or a check that stopped the rewrite, its words are given back. The same goes for a rewrite your agent turns down with keep_original. When a text has more words than the month has left, the agent gets it back whole and unchanged, with its word count, the words left and a link to change plans. Waiting on or deciding a rewrite that already exists never counts and never fails. See the pricing table for the plans.

Billing

interpt sells the paid plans directly and sends the invoices. Stripe takes the payment and calculates tax at checkout. Prices are in US dollars. VAT and other taxes are added at checkout where they apply. The billing portal, opened from Settings, lets you change plan and cancel. An upgrade starts at once. A downgrade or a cancellation takes effect at the end of the period you paid for. If a payment fails, you have 7 days to fix it before the account moves to the Free plan.

How long text is kept

Text is kept 30 days on every plan. It is deleted from the live database 30 days after the decision, and from every backup within 48 hours after that. With "Check before it's used" off, the decision is made when the rewrite comes back. A rewrite that nobody decides expires on the same schedule from the moment it was sent. rewrite_result then returns the status expired with an instruction to send the text again if it is still needed, and the rewrite leaves your queue.

The window in which a commit or email that came back from reright gets through the hook is 24 hours and does not depend on retention.

Moving to Free does not delete text early. Deleted text cannot be recovered. Backups only go back about a day, so point-in-time recovery is limited to that.