How it works
A rewrite is a measurement, a plan, and a check
Handing a document to a model with the instruction “make this sound human” is not a product; it is a coin flip with a nice interface. What follows is the actual pipeline every rewrite runs through, including the parts that never call a model at all.
Six stages, and what each one is for
Three of these stages never call a model. That is not a cost decision — a measurement is reproducible and a judgement is not, so anything that can be computed is computed.
- 01No model call
Read and measure
Your document is split into blocks, and roughly twenty style signals are computed from it.
Every signal is a measurement turned into a severity between 0 and 1 against an explicit threshold, not a yes-or-no flag: how far sentence lengths spread around their mean, how often sentences open the same way, transition and hedge density, corporate filler, nominalisation load, paragraph symmetry, restatement, and more.
Human writing trips these detectors all the time, and that is intended. A signal only becomes something to act on once it is well past its threshold.
This stage is ordinary computation. Nothing is sent anywhere.
- 02Local + model
Record what must not change
Everything countable is extracted before a single word is rewritten.
Numbers, percentages, currency, dates, years, quotations, citations, URLs, email addresses, acronyms and load-bearing hedges are found by pattern matching. This layer always runs and is authoritative, because comparing strings is a far more reliable check than asking a model whether it preserved your figures.
Above 45 words a second pass records what regular expressions cannot see: the claims being made, the conclusions being drawn, and the causal relationships between them. If that pass fails, the rewrite continues with the lexical constraints alone rather than falling over.
- 03No model call
Plan the rewrite
The plan is derived from the measurements, deterministically, before any rewriting happens.
Each directive traces back to a specific signal, so the instruction the model receives is about your document — the words that are being overused, the average your sentence lengths are clustering around — rather than generic advice about good writing.
The plan also sets a change budget. Text that already measures as well written gets a small budget and an explicit instruction to leave good sentences alone. That is what stops the product from rewriting for the sake of looking busy.
Documents over 900 words are divided into chunks at paragraph boundaries so no chunk is rewritten without the context around it.
- 04Model call
Rewrite
The strongest available model rewrites the document with the plan and the constraint list in front of it.
Blocks come back in the same structure they went out in — same count, same order, headings still headings, lists still lists — so the result can be compared with the source paragraph by paragraph.
Your text is passed as data and never as instruction. A document that contains something looking like a command to the model is treated as prose to rewrite.
- 05Local + model
Verify against the original
The rewrite is checked back against your draft, in both directions.
Deterministic checks run first and always: every extracted value is looked for in the rewrite, and every value in the rewrite is looked for in the source. The first direction catches omissions. The second catches fabrications, which is the failure mode that matters most here.
Above 60 words a semantic pass looks for the drift string comparison cannot see — a claim quietly strengthened, a qualification dropped, a causal link reversed. If that pass fails, the report degrades to "deterministic only" and says so, rather than failing your rewrite.
- 06Model call
Repair only what drifted
Failing paragraphs are regenerated with their specific problems named. Everything that passed is kept.
Regenerating a whole document to restore one dropped figure would cost more, take longer, and throw away work that was already correct.
Repaired blocks are re-checked deterministically, so a repair that reintroduced a problem cannot be reported as clean. Repair runs at most 1 time; past that the report tells you what is still wrong instead of looping.
Verification catches the failure modes it can name, and it catches them well. It is still a check rather than a proof, which is why every rewrite arrives with a diff and your original sitting next to it. You are meant to be the last reader.
Four things it deliberately will not do
The constraints matter more than the capabilities. These are the ones the product is built around.
- It will not add anything
- No invented anecdotes, no opinions your draft did not hold, no examples that were not there. A rewrite that reads better because it made something up has failed, and the validator treats a value present in the rewrite but absent from the source as a fabrication.
- It will not flatten a register it was asked to keep
- Academic mode preserves every hedge and qualification, because in academic writing those carry meaning. Each mode declares which measured signals it should tolerate, so the planner does not chase a signal that is correct for the kind of writing in front of it.
- It will not rewrite what is already good
- The plan sets a change budget from the measurements. Prose that measures as well written gets a small budget and an explicit instruction to leave good sentences where they are — and paragraphs it leaves alone show up in the diff as untouched.
- It will not make a claim about detection tools
- Timbro is not built to interact with AI detectors or plagiarism checkers, is not tested against them, and does not promise anything about how they will score a document. Where a rule requires you to disclose AI assistance, that rule still applies.