Publish your docs for free. Keep them current together.
Write, collaborate and publish from your GitHub repo, as part of your existing workflow. Your team gets a visual editor, your coding agents work on the same Markdown files, and your readers get a searchable docs site—built for people and agents.
- One place to keep docs current. Edit, comment and collaborate in the browser, or update the same files through your coding tools.
- Your repo holds the source and history. Every save is a Git commit, keeping documentation alongside your project.
- Share with the right readers. Keep documents private, share them by link or publish them, with Markdown pages and
llms.txtfor agents.
Free docs hosting. Fair plans for teams, priced per organization. Agent tokens never take a seat.
Or hand it to your coding agent
Read https://notdocs.dev/SKILL.md and set up notdocs in this repository.The agent reads SKILL.md, installs the CLI, initialises the repository and connects MCP.
Three moves, and your docs are ready to publish.
No migration, no sync job, no second copy of anything. The files you already have get a place to be read, written and worked on.
- 1
Connect a repository
Install the GitHub App and pick a repository. A docs folder is a workspace already.
- 2
Edit it as pages
Frontmatter becomes properties, a code fence becomes a board, and a save is a commit of the file.
- 3
Let your agents in
Claude signs in; an agent that runs unattended gets a token. One MCP server, the same files, and what they change shows up in the history next to what you changed.
notdocs is for solo founders, agencies and engineering teams who ship with agents.
Same document, same moment, one file.
A document open in more than one browser is one session. Everybody types into it and sees everybody's caret; the server writes the markdown file after a pause, and an agent's change to that file lands in the session merged, not lost.
One session per document
Open a document somebody else has open and you are in it: their keystrokes, the title and the properties as they are typed, and their caret with their name.
The server writes the file
After 1.5 seconds of quiet, 10 seconds at most, and when the last person leaves. One change in the history per pause, not one per keystroke; ⌘S writes now.
Agents land in the session
A write over MCP, a push or a checkout is folded in where the lines differ. Where they collide the session wins, and the file’s version stays in the history.
An assistant that knows the project, and asks before it writes.
It works on the same documents you do, through the same operations, with your permissions. Ask it a question, hand it a draft, or turn a meeting into tasks; you see every change before it lands.
Answers from your documents
Ask what is blocked, what was decided or where something is written down. It searches the project, reads the pages, runs query blocks and lists the documents it drew on under every answer.
Drafts and edits in place
It writes a spec, a decision or a meeting note from a template, rewrites a page, or moves a task across the board, and every change lands in your repository, in its history.
Nothing written until you approve
Each write arrives as a diff. Approve it, turn it down, or untick the hunks you do not want and keep the rest.
Tasks out of any page
/tasks pulls the tasks out of the open spec or meeting note and files them when you say so. /summarize, /blocked, /decisions and /review start the usual questions in one word.
Rewrite a selection
Select a paragraph and pick Improve, Shorten, Expand, Plain or Grammar, or say what you want. The result streams into a preview you keep, discard or try again.
Your permissions, your key
It reads and writes only what the person asking can. The assistant runs on a model we choose and keep current, on the usage the paid plans include or on an AI key of your own.
Everything a workspace does, without leaving the repository.
Boards, types, comments, search, merges and agent access: each one is a view of the files, and each one works the same for a person and for a program.
Edits merge
An agent never overwrites your work. Every write carries the version it was read from, two edits to one file are merged, and a real collision comes back as a diff with a recommendation instead of a silent loss.
A code fence is a board
A task board with no database behind it. Drag a card and the frontmatter of that file changes, and the history says who moved it.
One history for everyone
Agents catch up without re-reading everything. People and agents share one change feed, with a cursor an agent polls for what changed since it last looked.
Search that reads every page
Find the page you half remember. Full text for the exact phrase, embeddings for the meaning on the paid plans, in the palette for you and as a tool for the agent.
Typed documents
Documents have shape without rigidity. Page, task, decision, spec, meeting, launch and any type you declare in the repo config, with the schema checked on every write.
Comments live in the repo
Comments your agents can act on. Threads are YAML files in the repository, committed like everything else, so an agent reads the review, does the work and resolves it.
Tokens you can take back
Give an agent exactly what it needs and nothing more. One project, one scope, the folders it may write. Revoke the token and its next request fails.
A page is a markdown file. Here is what one can hold.
A fence that draws a diagram, a tab that lists what links here, a query that lays itself out on a calendar, a key that publishes a folder as a site, a letter that leaves as a Word file: each is plain text in the repository, shown for what it is.
Fences that draw
Diagrams, file trees and highlighted code without leaving markdown. A mermaid fence is its diagram, a tree fence a file tree, HTML is shown as what it draws, and the file keeps the source.
Every link, backwards
Rename or move a page and nothing breaks. Every link to it is rewritten in the same commit, and the Links tab shows what depends on a page, by wikilink or by path, before you touch it.
A calendar and a gallery too
One query block, five ways to see it. The same block lays its documents on a month grid by their date or shows them as cards with a cover, beside the board, the table and the list.
Published by one key
Publish a handbook, a docs site or a single page by setting one key. visibility: public lists it on your site, on your subdomain or your own domain, and any agent reads the page as markdown at its .md address, with no account.
Documents that leave the repository
Write contracts, invoices and proposals in markdown and send them as Word or PDF. Letters, memos, reports and the legal set (terms, privacy policy, NDA, DPA, SLA) are written in MDD, the markdown document format, with a letterhead and a signature block, exported to Word or printed to PDF from the page.
And the rest of it.
One price for the whole organization, a Notion export or a vault becomes a workspace, an agent sets the whole thing up from one URL, and a broken link fails the build before it ships.
One price, however many of you
Plans are priced per organization, never per seat, so inviting someone costs nothing. Free publishes a site for two people, and every plan, Free included, has the MCP server, the CLI and project tokens.
PricingMove in from Notion or Obsidian
A Notion export becomes typed pages with its databases as frontmatter; an Obsidian vault keeps its files. A repository that already has markdown gets a survey from notdocs init, which reads it in place or tidies it under one root with the links rewritten.
Switch from NotionHand an agent one URL
notdocs.dev/SKILL.md tells a coding agent how to install the CLI, initialise the repository and connect MCP. notdocs init writes a short section into your CLAUDE.md or AGENTS.md too.
SKILL.md and llms.txtBroken links never reach main
notdocs links finds every link, image and wikilink on the branch that reaches nothing, and notdocs lint finds the markdown that renders as text instead of what it is. Both exit non-zero, so they gate CI, and lint --fix repairs what it can in one commit.
The CLI
Give your agent the same workspace.
One MCP server with the same operations as the web app and the CLI. On your machine it runs over stdio against a folder; hosted, over streamable HTTP: Claude and other clients sign in over OAuth, and an agent that runs unattended uses a project token you can revoke. All of it is on every plan, Free included.
# A folder on your machine, no accountclaude mcp add notdocs -- notdocs mcp --serve ./my-project# Hosted: link a checkout to a workspace, then add the servernotdocs link --url https://acme.notdocs.dev --project handbookclaude mcp add notdocs -- notdocs mcpOne tool per operation
The agent sees the same operations you use, with the same inputs. A write returns a conflict instead of overwriting a person.
docs_listdocs_getdocs_createdocs_updatedocs_backlinksquery_runsearchchanges_sincecomments_listcomments_addcomments_resolvetemplates_listbranches_list+ resources, promptsWorks with Claude Code, Cursor and any client that speaks MCP. Set it up
Questions people ask first.
Where does my content live?
What happens when two edits collide?
Can two people edit the same document at once?
Which agents work with it?
Does the assistant train on my documents?
How do I leave?
What does it cost?
Publish your docs for free.
A docs folder in a GitHub repo is enough. Sign in, install the GitHub App, set the docs to public, and the site is live.
Do we already have a form for this, or is it new?
Sales has one at /contact/sales. I linked it in the spec.