AI writes Markdown
Agents read, write and review plain .md natively. Files in the repo are where they are strongest, and where your engineers already review changes.
Google Docs
for your Markdown files.
Your specs, PRDs and runbooks already live as .md in the repo,
because that is where AI agents work best. Notula gives them back everything
you left behind: comments, replies, collaboration and a document tree anyone
can use.
Free download. No account, no server. macOS and Windows.
Your documentation already moved.
Your tools did not.
So the docs followed
Specs, PRDs, RFCs and runbooks left the wiki and landed next to the code. That was the right call, and nobody is moving them back.
And everyone else lost their tools
No comments, no threads, no way to browse, no way to edit a paragraph without learning a code editor, a diff and a rebase first.
Everything you use in Google Docs,
on files that never leave your repository.
Google Docs Markdown in a code editor Notula
Comment on a passage, reply, resolve
Told the moment somebody comments or names you
See who has changed a document since you opened it
Write without seeing any syntax
Browse documents in a tree, not a file list
Back and forward between linked docs
Usable by someone who has never opened a terminal
Files stay plain .md in your own repository
AI agents can read and edit the same files
Reviews as a normal pull request
Works with no network and no vendor account
Tells your AI agent how the workspace is organised
Speaks git and nothing else, so it works with what you have
GitHubGitLabBitbucketGiteaSSH keysGit LFSSubmodulesNo remote at all
Only the documentation, none of the code
Open a repository with thousands of source files and get a clean tree of Markdown. Folders with no documents in them never appear.
How the workspace is built
No Markdown syntax. Ever.
WYSIWYG, not live preview. No hashes, no asterisks, no table pipes, not even on the line your cursor is on. The file on disk stays ordinary Markdown.
See what it writes back
The comments you actually miss
Select a passage, leave a comment, reply, resolve.
And they are told, by name
Git, without teaching git
Every version of the document is there to read and to bring back. Nobody is ever shown a rebase, a stash, or the words detached HEAD.
What it will never doYou are never the last to know
and nothing ever changes under your cursor.
Somebody named you
Your machine tells you, with the sentence they wrote.
Maya Chen named you
Is the order the real problem, or the number of fields?
checkout-redesign.md · platform-docs
- Clicking it opens the document at that paragraph, not at the top.
- It keeps watching repositories you do not have open, with the window closed.
- Two at a time arrive on their own; more than that arrive together, so they stay read.
Something changed
And you did not have to go and ask.
- Every document the rest of the team has moved on is marked in the tree, with who moved it and when.
- Your own unpublished work is marked the same way, so nothing waits in a drawer you forgot about.
- It looks every thirty seconds while you are working, and every few minutes while you are not.
- All of it is read from the fetched branch, so the document on screen is still exactly what you left until you take the change.
Threads that live in the repository
A conversation is committed next to the document it is about, so it arrives with the clone and outlives every account.
- Documents stay clean. No invisible anchors, no block IDs, no HTML comments.
- Anchored by the quoted passage and its context, following the W3C Web Annotation model.
- An append-only log with a union merge driver, so two people commenting at once cannot conflict.
Navigates like a browser
Follow a link and the document opens in the same pane. Back and forward return you to exactly where you were, scroll position included.
- Every pane keeps its own trail, so a reference held open in a split is never disturbed.
- Relative links between documents resolve the way they do on the host.
- Non-Markdown link targets open read-only instead of being handed to another app.
A one-character edit stays a one-character diff
Notula writes back only what changed. Across 6,000 real documents, 96.4% of blocks survive an edit untouched.
Where the project actually isYour agent gets a briefing, not a guess
Notula writes down how the workspace works, and points Claude Code at it.
-
It writes
notula-claude.mddescribing the document types, the fields, the layout and the commands, and borrows three lines of yourCLAUDE.mdto point at it. It never overwrites what you wrote there. -
The briefing carries the rules that are invisible once broken.
Renaming a document is
notula docs move, because the comment log is filed under the document's path and a plainmvorphans every thread on it. -
There is a command line behind that - documents, types, fields,
status, all with
--json- so an agent operates the workspace instead of guessing at files. - When an agent rewrites the document you have open, the change lands in front of you instead of being clobbered.
The three lines in your CLAUDE.md
<!-- notula:begin -->
This repository is edited with Notula.
What it keeps here: @notula-claude.md
<!-- notula:end -->Three things happen, and none of them are your problem
Point it at a repository
The one your engineers already push to. Notula reads it with git ls-files, so a repository with thousands of source files opens instantly and .gitignore is respected for free.
Write like it is a document
Headings, tables, links and images, with no syntax on screen. What lands on disk is ordinary Markdown that reviews in a normal pull request.
Everyone stays in sync
Notula fetches in the background and tells you what arrived. Publishing is one sentence about what changed, and if two people edited the same paragraph you pick between two versions, not between conflict markers.
Built for repositories other people are working in
Notula is a guest in someone else's worktree and behaves like one.
Scoped to its own files
Every git command carries an explicit pathspec. Notula never stages the whole worktree.
Your colleague's work is untouched
Open a repository that has someone else's uncommitted changes in it. Notula never stashes and never rewrites history.
No branches, no pull requests
Notula commits to the branch you are on and never creates or switches one. If it is protected, it says so before you edit.
Your documents go nowhere
There is no Notula server and no account. Documents, comments and history live as files in the repository, and the only things the app talks to are your own git remote and the releases page it updates itself from.
Where it actually is
Early, but running. This is the honest state of each part today.
Writing WYSIWYG with no syntax on screen. Tables, diagrams, images, footnotes, code
Markdown round trip Byte-identical on 6,000 real documents, and 96.4% of blocks survive an edit untouched
Workspace and navigation Tree, quick open, full-text search, split panes, per-pane back and forward, history
Comments and review Threads, replies, mentions, suggested edits, a review inbox and desktop notifications
Git Background fetch, publishing in one sentence, conflicts as a choice between two paragraphs
macOS download Apple Silicon and Intel, updating itself. Not signed yet, so opening it takes one command
Windows download An installer for x64 and arm64, updating itself. Not signed yet, so SmartScreen asks once
Linux Not built yet
The decisions that matter are written down before the code, using GitHub Spec Kit. The source is private while the app is this young. The downloads are not, and every build carries the release notes for what changed.
Questions people ask before they point it at a work repository
Does it change my repository?
Only the files you edit and the comment log beside them. Every git command carries an explicit pathspec. It never stages the whole worktree, never stashes, never rewrites history, and never creates or switches a branch.
Do I need to know git?
No. You open a folder, write, and publish with one sentence about what changed. Nobody is shown a rebase, a stash, or a conflict marker.
Does it work with private repositories?
Yes. Notula drives the git already installed on your machine, so the SSH key or credential helper you already use is the one it uses. It never asks you for a password and stores no token of its own.
Where do the comments live?
Committed in the repository next to the document, as an append-only log with a union merge driver. They arrive with a clone and outlive every account, and the documents themselves stay clean.
Will it slow down on a large repository?
No. It asks git for the file list rather than walking the disk, keeps the Markdown, and respects .gitignore for free. Thousands of source files open as a tree of documents and nothing else.
How current is what I am looking at?
Notula checks every thirty seconds while you are working, and every few minutes when you are not. Anything that arrived is marked with the name of whoever wrote it, and stays marked until you take it - the document on your screen never changes on its own.
Is it free?
The app is a free download. There is no account to create, no server to sign in to, and nothing to pay for anything on this page.
Can I keep using Claude Code in the same repository?
That is the point. Notula writes a briefing describing the workspace and links it from your CLAUDE.md, so the agent knows the conventions. When it rewrites a document you have open, the change lands in front of you.
Is the source open?
Not while the app is this young. The builds are public, every release carries its notes, and the decisions that matter are written down before the code.
Your docs are already Markdown. Make them usable.
Free, and free of accounts. macOS on Apple Silicon and Intel, Windows on x64 and arm64, both updating themselves from then on. Linux follows.
Apple Silicon. On an Intel Mac, or on Windows. 64-bit. On Windows on Arm, or on macOS.
Neither is signed yet, so the first launch takes one extra step. The download walks you through it.