Wilow has one document that says what the product does: a product knowledge base, one section per user-facing feature. Everything written about the product is supposed to start there. The rule inside the company is that a durable document never restates a volatile fact — a price, a tier, what a feature does — and points at the knowledge base instead.
A document like that is only true on the day someone writes it. The product kept shipping: between 4 June and 29 October 2026 the knowledge base was edited on dates spread right across the period. Keeping it true is not a writing job, it is a noticing job — knowing that a change nobody announced made the third paragraph of a section wrong — and the evidence for what shipped is scattered across the code, the tracker, the recorded meetings and the chat.
So the document had the usual fate. The parts nobody revisited went on describing a product that had moved, and the only way to find out which parts those were was to read everything that had happened since.
What we built
An agent that reads the sources in a fixed order, every night, and edits only the sections that changed. Each run goes through the same steps.
Step 1
Read the document
The whole knowledge base, in full, before anything else is read or written.
Step 2
Read what shipped
From the code itself, not from a summary of it. That is what decides whether a thing exists.
Step 3
Read the tickets behind it
What each change was meant to do, which is not always what the code says it does.
Step 4
Read the meetings and the chat
Everything since the last run: recorded meetings, finished work sessions, the team channel. This is where the why lives.
Step 5
Rewrite only what changed
A section nothing touched comes out of the run exactly as it went in.
Step 6
Stamp every section it rewrote
Who the section is for, how the claim was verified, the date, and whether the feature is live.
Step 7
Write down what it cannot settle
Two sources that disagree are recorded as an open conflict in the section, not resolved by a guess.
Step 8
Publish, and record the run
The document goes to the team wiki, every edit goes in a dated changelog, and the run writes its own digest.
One run of the agent, from the document it reads first to the record it leaves behind.
Safeguards
It never guesses. Every claim carries how it was verified, on three tiers: nobody has looked, the code has reached the main branch, or someone has actually seen the working thing in the product. The weakest tier licenses nothing.
A new positive claim needs the strongest tier. Code on the main branch is proof that something exists, not proof that anyone can use it yet, so it is not enough to put a new claim on a page that sells.
It never deletes a section. A feature that has been removed is marked retired with the date. The history stays readable.
It cannot use the website as its own evidence. An earlier tier let a live page count as proof of a claim; since policing those pages is the agent's own job, that was circular, and it was retired. Where a page is the only source, the claim stays unverified.
Open conflicts stay open. Where two sources disagree, the section says so, in writing, with both sides and where each was read.
The sources are the approval. A change the rules cover, the agent writes up itself; anything that turns on a judgement nobody has made is written down as an open question instead.
The result
The document still describes the product, and no person has to keep it up. Each night the agent reads what shipped that day, rewrites the sections that change made wrong, and publishes. There is a run record for every night from 11 October up to 30 October 2026, and a dated changelog entry for each night that actually changed something — a night when nothing shipped leaves the document alone and says so.
A section before the rulebefore
Feature
Described in the present tense
Who it is for
Not stated
How we know
Not stated
Last checked
Not stated
Still live?
Assumed
The same section, stampedafter
Feature
Described in the present tense
Who it is for
A buyer, or internal only
How we know
Seen working in the product
Last checked
A date, on the section
Still live?
Live, unreleased or retired
The line the agent writes under every section it rewrites. Sections written before the rule existed carried none of it.
Frequently asked questions
Can an AI agent keep product documentation up to date?
Yes, and this one does it each night on a live product. It reads the whole document first, then what shipped, then the tickets, meetings and messages behind it, rewrites only the sections that change made wrong, and publishes. There is a run record for every night from 11 October up to 30 October 2026.
How does it know what changed?
From the code, first. What shipped is read out of the shipped log rather than out of a summary, and the tickets, recorded meetings and team chat are then read for what the change was meant to do and why. A closed ticket on its own is the weakest kind of evidence and licenses nothing.
What stops it writing something that is not true?
Every claim carries how it was verified, and the tier decides what the claim may be used for. A new positive claim on a page that sells needs someone to have seen the working thing. Where two sources disagree, the section records the conflict instead of picking a side.
Does anyone still have to edit the document?
Only to answer the questions the agent writes down. It never deletes a section, never resolves a conflict on its own, and marks a removed feature as retired with the date, so what is left for a person is deciding the things only a person can decide.