How is an AI agent a 'peer' in Quire rather than a background file-rewriter?

Quire's agent runs through a local MCP server (quire-mcp) and joins the same Yjs CRDT session you are typing in. That means you see its live cursor, every span carries its author identity, edits can be proposed in suggest mode and never touch the file until you accept them, and you can revert one agent's contributions without touching the paragraphs you wrote beside them. Because it is a CRDT session rather than a whole-file rewrite, you can keep typing straight through its edits without a conflict.

Does Quire let me publish my Markdown to LinkedIn, X Articles, Medium, or Notion?

No, and that is by design. Quire returns a clean .md file on disk; the publish step that turns Markdown into platform rich text is a separate conversion. That is exactly where md2rich slots in: paste the finished Markdown into md2rich, copy the rendered HTML, and drop it into LinkedIn, X Articles, Medium, or Notion. Quire owns the write-and-review end of the pipeline and md2rich owns the publish end.

Is Quire actually private and local-first?

Core editing is offline: no Quire account, no signup, no telemetry, no advertising SDK, and it binds 127.0.0.1 by default. The trade-off is that Quire has no authentication at all, so the README warns that --host 0.0.0.0 means anyone who can reach the port can read and edit the vault. Optional features widen the surface: --git makes local snapshots (commits only Markdown paths Quire changed), Discover contacts GitHub only after you search, and --allow-exec lets a selected fenced code block run as your own OS user.

2026-09-08 · 7 min read

Quire 2026: AI Agents Join Your Markdown Session as Peers

Q: How does Quire's Markdown fidelity compare to a Google Docs import-export round trip?

Quire publishes a byte-fidelity test suite that runs a fixture containing YAML frontmatter, task lists, tables, fenced code, Mermaid, wiki-links, footnotes, raw HTML, and comments through an unchanged editing session and checks it stays byte-for-byte stable. The README also documents that the same fixture changed by 22 inserted and 30 deleted lines after an untouched Google Docs import/export round trip. The point is that Quire keeps syntax-rich Markdown as source text instead of converting it through a cloud renderer, which matters if you are going to hand that file to a converter afterward.

A local-first tool that turns a folder of plain Markdown into a live CRDT workspace where AI agents edit beside you with a visible cursor, per-line attribution, and suggest mode — and your files stay the source of truth the whole time.

The moment AI writing tools went from "chat that returns text you paste" to "an agent that edits your file," they hit a wall I hit almost weekly: the agent rewrites the whole document behind my back. It is not that the output is bad. It is that I cannot tell what it changed, I cannot accept half of it, and if I want to undo the agent's voice I am also undoing my own edits, because there is just one blob of text with no provenance. So when a small tool called Quire showed up on Hacker News on September 7, 2026 with the line "humans and AI agents editing local Markdown together," the part I cared about was not another Markdown editor. It was the claim that the agent is a peer in the same editing session, not a process that rewrites your files. This article is about why that distinction matters, and where Quire sits in a write-once-publish-anywhere Markdown stack.

What Quire actually is

Quire is an open-source project by developer heetdalsania — repository heetdalsania/quire, TypeScript, AGPL-3.0, published on npm as quiredocs. It is brand new: the first beta, 0.1.0-beta.1, was released on 2026-08-28, followed by beta.2 on 08-29 and beta.3 on 08-30. The whole pitch fits on one line: point Quire at a folder of Markdown and the original .md files become a live multiplayer workspace, with no import step, no cloud copy, and no conversion round trip.

Quick start is genuinely quick. It needs Node.js 22 or newer, and there is no account, signup, or telemetry.

# point Quire at a folder of Markdown, then open http://127.0.0.1:4321
npx quiredocs ~/my-notes

The editor binds 127.0.0.1 by default and core editing makes no outbound requests. A --demo flag starts a disposable three-document vault that is deleted when Quire stops, if you would rather try it on dummy files than on your own notes. Multiple browsers can open the same file, remote cursors show up, offline reconnects merge cleanly, and the filesystem stays authoritative: you can edit the same file in vim or git pull mid-session and Quire merges the change as a delta rather than overwriting you.

Why "the agent is a peer" is the real engineering claim

Plenty of tools say they support AI. Quire's claim is narrower and more specific: the agent connects through a local MCP server (quire-mcp) and joins the same Yjs CRDT session you are typing in. Concretely, that gives you four things that a background file-rewriter cannot offer:

Suggest mode. Agent edits can be proposed rather than applied. They show inline in the document and never reach disk until you accept them.
Attribution. Every span carries its author. Toggle Authors and the text is tinted by who wrote it — you versus Claude Code versus Cursor.
Revert by author. Remove one agent's contributions without touching the paragraphs you wrote beside them. This is the undoing-my-own-edits problem, solved.
Typing through edits. Because it is a CRDT, you can type straight through the agent's changes and nothing conflicts. The README's demo shows a person and an agent editing the same document at once with no reload and no conflict.

The MCP endpoint is where the agent integration lives. You keep Quire running, add its local server to your client, and the agent gets a presence identity and a cursor. The setup commands are copy-paste one-liners for Claude Code, Codex, and Cursor:

# Claude Code
claude mcp add quire -- npx -y -p quiredocs@latest quire-mcp \
  --url http://127.0.0.1:4321 --name "Claude Code"
# Codex
codex mcp add quire -- npx -y -p quiredocs@latest quire-mcp --url http://127.0.0.1:4321 --name Codex

The tools the agent gets — list_documents, read_document, edit_document with a suggest option, append_document, list_suggestions, list_comments, add_comment, search_vault — are scoped to the folder you passed on the command line, and paths outside it are rejected. You are not giving the agent blanket filesystem access; you are giving it read and edit tools over one vault.

The three-way positioning nobody else fills

Quire's README is honest about where it sits with a small table. Most tools do two of these three things; Quire claims all three:

Tool	Multiplayer	Agent-native	Plain files
Notion · Outline · HedgeDoc	Yes	No	No
Obsidian · Logseq	No	Partial	Yes
SoloMD · CollabMD	One or the other	—	—
Quire	Yes	Yes	Yes

That last column is the one most collaboration tools give up. A cloud "Google Docs for Markdown" keeps a converted copy in its own database and treats your local file as an import/export boundary. Quire takes the opposite direction: the files in your local folder stay authoritative while people, agents, external editors, and git all work with them, and collaboration state lives separately in a .quire/state/ directory you can delete if you only want the clean Markdown back.

Fidelity, provenance, and why they matter before you publish

Quire ships two features that sound niche until you are the one who needs them. The first is a byte-fidelity guarantee: the release suite runs a fixture holding YAML frontmatter, task lists, tables, fenced code, Mermaid, wiki-links, footnotes, raw HTML, and comments through an unchanged editing session and asserts it stays byte-for-byte stable. The README highlights the contrast by documenting that the same fixture changed by 22 inserted and 30 deleted lines after an untouched Google Docs import/export round trip. If you are going to hand that file to a converter later, you want the source to survive an editing session intact, not quietly normalized by a cloud renderer.

The second is the provenance receipt. One click turns a document into a shareable, self-contained HTML page that records how much a person wrote vs. how much an agent did, which suggestions were accepted, and a replay of the document being written. For anyone publishing AI-assisted work — and especially for a LinkedIn audience that has gotten savvier about AI slop — being able to point at exactly what an agent contributed (and what you accepted) is a genuinely differentiator. Review requests and share links are scoped with view/comment/edit capabilities enforced server-side, and reviewers can comment without any account.

A short Markdown-to-rich-text sample

Here is how a collaboratively-written draft might look in Quire's source panel, and what the same block becomes after a single paste through md2rich.

## What we changed this week

The agent drafted a **release note** in suggest mode; I accepted two of its
three edits and wrote the third myself.

1. Attribution shows an agent wrote the first two sentences.
2. Rows revert by author — no lost paragraphs.
3. The plain .md file never left the folder.

Publish with md2rich once the review is closed.

After a single paste through md2rich, the same block becomes a styled <h2>, three numbered list items, the inline <strong> and <em> emphasis, and a working code span. Nothing leaves the browser — md2rich runs entirely client-side — so a draft that several humans and one agent shaped in Markdown lands on LinkedIn or X looking exactly the way you reviewed it, with no third-party renderer deciding what your formatting means.

Where Quire fits your pipeline, and where it does not

Quire is a write-and-review tool, not a publish tool. The output it produces is a .md file on disk, collaboration history in .quire/state/, and a provenance receipt if you want one. Once the review is closed, the Markdown still has to become rich text for the places your readers actually scroll — LinkedIn's article editor, X Articles, Medium, Notion, a Substack post. That conversion is the part md2rich exists for. The two tools sit back-to-back on the same loop: Quire is where you and your agents finish a draft you can defend, md2rich is where you finish the post.

The other Markdown tools covered on this site occupy neighboring slots in that same loop: Notes Plus is the capture end (an Apple Notes-style scratch pad), MarkFlowy is the long-document authoring end, SkillDocs is cloud collaboration around the skill files your agents run on, and Quire is the part where the humans and the agents actually edit prose together in real time with full attribution. If your problem is "my agent rewrites the file and I cannot see or undo the changes," Quire is aimed directly at you.

The honesty check: what Quire does not promise

For a day-one tool the README is unusually blunt about limitations. Quire has no authentication, so binding to --host 0.0.0.0 genuinely means anyone who can reach the port can read and edit every document — the threat model lives in SECURITY.md. Code execution is off by default and only runs under --allow-exec, which refuses to run anything when Quire is bound beyond loopback. Git snapshots are off by default and committed only Markdown paths Quire changed. The package has no runtime dependency downloads and no preinstall/install/postinstall hooks, and there is no analytics, advertising SDK, auto-updater, background service, or payment integration. It is free to run and self-host, and the agent you connect to it is the one that pays under its own provider plan. At one star on GitHub as of this writing, it is a very fresh beta — read the docs, try the --demo vault before you point it at real files, and do not widen its network surface until you have read SECURITY.md.

FAQ

What is Quire and why did it appear on Hacker News on September 7 2026?

Quire (github.com/heetdalsania/quire, AGPL-3.0, TypeScript) is a local-first Markdown collaboration tool. Point it at a folder of plain .md files and they become a live multiplayer workspace. It hit Hacker News on 2026-09-07 (story 49603593) with the pitch "humans and AI agents editing local Markdown together." The npm package is quiredocs at version 0.1.0-beta.3, and it requires Node.js 22 or newer.

How is an AI agent a "peer" instead of a background file-rewriter?

The agent connects through a local MCP server and joins the same Yjs CRDT session you are typing in. You see its live cursor, every span carries an author identity, edits can be launched in suggest mode so they stay off disk until you accept them, and you can revert one agent's contributions without touching your own paragraphs. Because it is a CRDT session rather than a whole-file rewrite, you can keep typing through its edits and nothing conflicts.

Does Quire publish my Markdown to LinkedIn, X Articles, Medium, or Notion?

No, and that is by design. Quire produces a clean .md file (plus optional collaboration state and a provenance receipt). The conversion from Markdown into platform rich text is a separate step — that is where md2rich fits. Paste the finished Markdown into md2rich.com, copy the rendered HTML, and drop it into LinkedIn, X Articles, Medium, or Notion.

Is Quire private and local-first?

Core editing is offline: no Quire account, no signup, no telemetry, binds 127.0.0.1 by default. The catch is that there is no authentication, so --host 0.0.0.0 means anyone who can reach that port can edit the vault. Optional flags widen the surface: --git makes opt-in local snapshots, Discover contacts GitHub only when you search, and --allow-exec runs a selected fenced block as your own OS user.

How does Quire's Markdown fidelity compare to a Google Docs round trip?

Quire runs a byte-fidelity test suite on a fixture containing YAML frontmatter, task lists, tables, fenced code, Mermaid, wiki-links, footnotes, raw HTML, and comments, and checks it stays byte-for-byte stable through an unchanged session. The README documents that the same fixture changed by 22 inserted and 30 deleted lines after an untouched Google Docs import/export. Quire keeps syntax-rich Markdown as source text rather than normalizing it through a cloud renderer — which matters when you plan to hand that file to a converter next.

Try it

If your AI workflow currently means "the agent rewrites my file and I hope for the best," give Quire a try on its --demo vault. When the collaboration is done and you have a clean Markdown draft you can defend, paste it into md2rich to turn it into rich text for LinkedIn, X Articles, Medium, or Notion. Same Markdown source, one tool to write it with your agents, one tool to publish it.