Skip to content
Docs Flowy
How it works

From a git push
to an answer your agent can cite.

No build step, no static site, no clone. Six stages between a commit landing and a document being current — and every one of them is a decision you can read.
Read byThe readerSearchYour agentsNotifications
Push

A webhook, verified before it is parsed

GitHub posts the push and we answer 202 immediately — it times out at ten seconds, so nothing is processed inline. The order is fixed and is never rearranged: raw body, then the HMAC signature compared in constant time, then parse. Reading the payload before verifying it is parsing something a stranger sent.

A force-push or a payload truncated at twenty commits cannot be diffed, so it forces a full resync rather than guessing. GitLab has no webhook here by default — we poll the branch head instead, because a webhook URL pasted into another tool’s settings is a config file with a better surface.

Setup

Live in three minutes

There is no import, no migration and no content to move. The documents stay exactly where they are, in the repository, owned by git.

  1. Connect a sourceA GitHub App with read access to the repositories you pick, or a GitLab access token you paste — gitlab.com or your own instance. The App can be revoked from GitHub at any time, and the token is refused outright if it carries a write scope or has no expiry.
    ~60 seconds
  2. Pick a repository and a branchThe branch list is read from the real repository rather than offered from a guess — a fixed main/master picker once pointed a connection at a branch that did not exist, and the sync then found nothing.
    ~30 seconds
  3. ReadThe docs root is found, titles are inferred, order is applied and the noise is grouped. There is nothing to configure on the way and there never will be.
    the rest
Freshness

Current, and honest about how current

The two providers behave differently and the difference is stated rather than averaged away.

GitHub pushes

A webhook fires on the branch you chose and only the files whose blob SHA changed are re-read. In practice a document is current within seconds of the merge.

GitLab is polled

There is no GitLab App and we refuse write-capable tokens, so we cannot create a webhook — deliberately. One branch-head request per repository per interval, roughly every five minutes. You can add a webhook yourself to make it immediate; nothing depends on it.

A move keeps its identity

Renaming or moving a file does not create a new document. Everything hanging off it — its review state, the notes on it, who has read the current version — moves with it.

Your browser finds out from the database

One live stream per tab, fed by the same transaction that recorded the change. No polling loop, and nothing on screen is replaced mid-sentence: a document you have open offers to reload rather than swapping its own paragraphs.

push → main · 4 files changed
webhooksignature verified· parsed after, never before
    A push arriving: two documents skipped because their content hash did not change, one re-read, and one recognised as a rename rather than a delete — so it keeps its document id along with its review status, notes and read receipts.
    The review loop

    Who may move what

    Two axes per document, and one asymmetry that the whole workflow layer rests on.

    A person may
    • Set a review state: draft, in review, validated, rejected, not applicable
    • Set an implementation state on the same document, independently
    • Leave a note anchored to a heading
    • Close a note — the only way one closes
    • Reject a document, with a reason written as a note in the same transaction
    An agent may
    • Read every document the credential admits
    • File an artifact, versioned, beside the documentation
    • Answer a note: agrees, disagrees, needs clarification, addressed
    • Move a note as far as awaiting confirmation, and no further
    • Claim it has started or finished building — with evidence, saved as a note

    Relax that and a reviewer’s objection disappears the moment an agent asserts it has been handled — silently, at scale, in the exact system a team adopted to stop that happening.

    Drift is measured against the content, never a timestamp. A status remembers the exact version it was set against, so editing the document renders validated · drifted rather than quietly keeping a badge that is no longer true. Two consequences follow and both are accepted: drift fires on a typo fix, and reverting a document makes an old validation current again for free.

    What it costs

    Only a call that reaches a model spends anything

    Everything that reads what is already stored is free, on every plan, however much of it you do.

    Spends a credit
    • A question answered10
    • A document summarised20
    • A turn of chat with a document20
    • A change summarised40
    Free, on every plan
    • Reading a document
    • The folder tree
    • Full-text search
    • Every sync, however often you push
    • Bundles and Copy for LLM
    • Every read tool on the agent surface
    • Docs health — nothing there calls a model
    • A summary that is already current

    An empty document makes no call at all — prompting a model not to invent is a request, not calling it is a guarantee. And document text only ever leaves the box for an organization that switched it on: the setting is off by default and turning it on is written to the audit log. See the pools per plan.

    Connect in three minutes. Disconnect in one click.

    Nothing is copied, nothing is migrated, and the repository never learns we were there.

    Start free