Docgent is the document workspace where agents draft at volume and humans review what actually changed. Git is the database. Every edit is a commit, every AI rewrite is a proposal, and every PDF is pinned to the commit that produced it.
An agent can now write a board paper from a Slack prompt in under a minute. That's not the problem.
The problem starts on the seventh turn. The document has been rewritten four times, by two models, from three data sources. Someone struck a paragraph in Google Docs. Someone else asked for "the shorter version." Which one went to the client? What changed between the draft you approved and the PDF that shipped? Six months later, can you produce exactly what was sent — not a regeneration that renders differently today?
Google Docs has no idea which edits were an agent's. Git is illegible to the people who need to sign off. A CMS adds a database and a sync layer — exactly the state that breaks when an agent and a human edit at the same time.
A line diff of an agent rewrite is a wall of red and green. Docgent diffs the document's meaning: rewrapping a paragraph reports nothing; a changed key figure reports the before and after value; a section that moved is reported as moved, not deleted and recreated.
Blocks carry an author-assigned identity, so the diff tracks a recommendation across revisions even when its text changes. Reviewing a 40% rewrite becomes a five-minute job instead of a re-read.
Triggered from chat, connected to whatever data they need. They read and write through the same API a human would, with a per-brand token.
PUT /api/doc/<brand>/<slug>
In Studio: semantic diff, one-click restore, live PDF preview. An AI rewrite arrives as a proposal held in memory. It never touches git until someone accepts it.
POST /api/rewrite → /accept
Draft → review → approved → released → superseded. Each gate is an ordinary git commit; sign-off lives in commit trailers and survives clone, mirror and export.
POST /api/status
An agent commit and a human edit are the same operation against the same objects. There is nothing to sync.
Every write carries the blob SHA it was based on. If the document moved, the write is rejected with a 409. Nothing is silently lost when an agent and a human edit concurrently.
A rewrite request returns text in memory. Only an accepted proposal commits. Three models can each take a pass and the history records one decision, not three drafts.
The .md file holds semantics only — never a colour, never a margin. If an author needs raw HTML to get an outcome, the vocabulary is missing a term. The validator hard-rejects the escape hatch.
Rendering is content-addressed and immutable. "What did we send in March" has a retrievable answer, not a regeneration.
Status transitions are commits. Sign-off is a trailer. There is no approvals table to fall out of sync with the document.
Document content is never interpreted as agent direction. What's in the file stays in the file.
A closed set of ~25 block types — callouts, key figures, recommendations, KPI grids — is the contract between writer and designer. Brands own the presentation layer: typography, palette, page geometry, running headers, cover treatment, as CSS design tokens.
The same strategy memo renders in a client's identity or your own without forking the content, the pipeline, or the agent that wrote it.
Install the skill, hand it a brand token, and any docs.docgent.io/<brand>/<slug> URL pasted into a thread becomes readable, editable, renderable and reviewable — with the propose-then-accept step enforced, not optional.
Strategy memos, client reports, where "which version is final?" is currently a Slack thread.
Papers that need an audit trail and a defensible record of what was approved.
One system, several brands, no forks.
Where AI already writes the first draft and review is the bottleneck.