Docs your agent writes. Docs your team owns.
Point Claude Code at a repo. It writes the documentation directly into a live, editable workspace over MCP — then keeps it current as the code changes, one section at a time. Markdown in a repo goes stale because updating it is a PR nobody writes. Feature Book makes documentation a database with section-level addressing, so an agent updates the one paragraph that changed and can prove it left the rest alone.
Retry policy
Requests retry on 429 and 5xx with full jitter. Backoff is capped at 30s and the total attempt budget is 5.
A[attempt] --> B{429/5xx} --> C[jitter]
Setup
Three steps, no config file
No API key to paste, no server-side setup. The agent discovers the auth server, registers itself, and sends you to a browser.
One command. The transport is plain HTTP.
Run /mcp → Authenticate. A browser opens; OAuth 2.1 with dynamic client registration completes. Access is scoped to exactly the workspaces you belong to.
From a session already open on your repo, invoke the packaged prompt by name.
Settings → MCP access, named after the client, revocable in one click without touching the others.Agent-native writing
23 tools, four prompts, one authenticated endpoint
The MCP server spans projects, pages, sections, versions and search. The agent reads structure before it writes, then addresses exactly the section it means to change. Four packaged workflow prompts cover the common runs.
updatePageSection( pageId: "pg_7d21", blockId: "blk_9f2c1a", ifVersion: 41, markdown: "## Retry policy\\n\\nBackoff is capped …" ) 200 ok version 42 · 1 section changed · 11 untouched
Section-level editing
Every heading is an address
Each heading in a page becomes an addressable section with a stable block id. An agent updates one section by id instead of rewriting the document, so an edit cannot silently drop a paragraph it was never asked about. The section rows mirror the authoritative document, so they can be diffed back against the page they came from.
Inside the workspace
Everything that happens after the agent stops typing
The page the agent wrote is the page you edit. BlockNote rich text with autosave, live in the browser — no branch, no review, no rebuild.
Blocks that survive a theme flip
Mermaid diagrams, KaTeX equations and syntax-highlighted code are first-class blocks — and they repaint correctly when the theme changes, rather than keeping the colours they were parsed with.
Icons, per page and per project
A curated icon set the agent can set as it writes, so the landmark pages — schemas, auth, deploys — are findable in the tree at a glance.
Navigation that keeps its place
The page tree lives in the layout, not the page, so expanding a branch survives navigation instead of collapsing on every click.
Activity, in the document
Recently edited headings are marked in place, keyed on the block's own id — so a mark cannot be wiped by a re-render.
Autosave, and no lost paragraphs
Edits save on a debounce as you type. A tool write racing that autosave is refused as a conflict rather than reverting your work.
Search that reaches into bodies
A command palette over titles and page content — scoped to one project, or across every project you can see.
A project graph, not a file list
Pages as nodes, with edges for both the parent tree and in-text cross-links. Orphans — nothing linking in or out — surface immediately.
Reading mode, and Listen
A plain article route that browser readers actually accept, plus text-to-speech with skip, rate and voice. No key, no bill, works offline.
Preferences restored before first paint
Theme, UI scale, document width and reduced motion are applied by a blocking script, so nothing flickers into place on navigation.
How the writes actually work
For the reader who assumes an agent will wreck the doc
Four mechanisms, in the order they protect you.
Section-level updates
The agent reads an outline, gets the block id of the section it means, and writes against that id. The rest of the document is never in the request, so it cannot be part of the mistake.
Compare-and-set
Every tool write carries the timestamp it read. If a person edited the page in between, the write comes back as a conflict — rather than reverting their work and reporting success.
Taken before the damage
A snapshot of the whole project — deleted pages included — is taken automatically before a destructive write, throttled so a long authoring run leaves one point from before it started.
Identity-preserving restore
Pages return to their own ids, so block ids and section history still line up afterwards. Labelled restore points are never pruned.
Compare
Against the two things you’re doing today
| Feature Book | Markdown in repo | General wiki | |
|---|---|---|---|
| Agent-writable | Authenticated MCP server | Via file writes, then a PR | Bespoke API glue |
| Section-addressable updates | By stable block id | Whole-file rewrite | Whole-page rewrite |
| Live editing by humans | BlockNote, autosave | Editor + branch + review | Yes |
| Version restore | Identity-preserving restore points | Git, at repo granularity | Per-page history |
| Search | Titles + bodies, one or all projects | grep, or a site build | Built in |
| Diagrams & math | Mermaid + KaTeX blocks | Renderer-dependent | Plugin-dependent |
Workspaces & access
Three roles, one settings dialog
Sign in with Google or GitHub. Roles are cumulative and explicit — every guard lists the roles it admits, so adding one is a decision each guard has to make rather than inherit.
One command away from docs that keep up
Your codebase already knows what the docs should say. Register the server, sign in once, and the next session can write them.