OpenMarkdown
A markdown editor you and your agent co-edit
266 followers
A markdown editor you and your agent co-edit
266 followers
A fast, light markdown editor that opens any `.md` file instantly. Your agent reads, writes, and co-edits the same file you're in — through a CLI, an agent plugin, and MCP. Local-first: no account, no telemetry, your files never leave your disk.
The local-first angle is exactly what pulled me in, and the co-editing through MCP feels genuinely useful. One thing that would make this a daily driver for me: a quick toggle to preview the markdown in a side pane with synced scrolling, so I can spot broken links or formatting drift while my agent is still writing.
OpenMarkdown
@berkantozg31053 So glad the local-first + MCP co-edit clicked for you 😊
This might already cover it: OpenMarkdown doesn't do a split source / preview pane — it renders live, inline, in the same pane as you (or your agent) type. So formatting drift shows up the moment it's written, with no second pane to keep scroll-synced. One button also cycles to reading mode (the clean rendered page) and source mode.
Personally, live preview has been the best experience for me — each line renders in place as I type. And when I do need the raw markup, source mode renders it with syntax colors (easier on my eyes) instead of a second pane. I kept it single to stay light.
Genuinely curious what a dual pane would give you over live preview — if it's a real gap, I'd love to understand the workflow before deciding.
(I attached two screenshot of the app under "live preview" and "source" mode for reference~
OpenMarkdown
@berkantozg31053
Congrats on the launch! I like the idea of keeping the editor lightweight while letting users bring whichever agent already understands their project.
The shared-file approach feels much more natural than copying content between an editor and a separate AI pane. I’m curious how you prevent collisions when the user and agent edit the same section at once.
Looking forward to trying it.
OpenMarkdown
@mingtian_zhang Thank you, that means a lot 😊
On the same-section case: agent writes are section-scoped and carry a hash of what the agent read. Before applying, `openmd` check you haven't changed that section under it — if you have, the write is rejected (not merged, not overwritten) and the agent re-reads and retries, so your edits are never clobbered. Different sections just interleave cleanly.
There's a step-by-step interactive agent demo on the landing page, and you can install by pasting a prompt into your agent: https://openmarkdown.dev Would love to hear how it feels~
Interesting call to make it "co-edit" instead of AI-suggest. How do you handle simultaneous
edits when both you and the agent are typing in the same block — CRDT-style merge or last-write-wins?
OpenMarkdown
@chetan00118 Great question!
OpenMarkdown's MCP supports section-level writing. There are two situations then.
1. When the agent writes to a different section than the one you're in, its edit lands as a scoped transaction in your live buffer. No reload, no lock.
2. When you're both in the same section, it's optimistic concurrency: every agent write carries a hash of what it read, and if you've touched that section since, the write is rejected (not merged, not overwritten) — your edits are untouched and the agent re-reads and retries. So on a real collision the agent yields 😊
A compare-and-swap per section is lighter, and it keeps the plain .md as the source of truth.
We are still looking for the best way to handle the concurrency for the best user experience and best performance. Let me know if you have any suggestions or other questions~
(ps: a new section for step-by-step interactive agent demo on the landing page should be sync'ed within the next 30 mins; please feel free to give it a try~)
@xueyanzhang Optimistic concurrency with per-section hash-CAS is a nice compromise — keeps .md as source of truth while letting agents yield gracefully on real collisions. That's more elegant than CRDT overhead for a doc format. I'll try the interactive demo when it's live. Thanks for the deep dive 🙏
OpenMarkdown
@chetan00118 Exactly — "yield gracefully on real collisions" is the phrasing I'm stealing 😄
Good news, no waiting — it's live now.
Thanks for the sharp questions! It means a lot.
the hash-CAS handles human vs one agent well, but what about two agents on the same file at once, say Claude Code in one terminal and a separate MCP client in another? does that logic run agent-to-agent too, or can both read the same stale hash and clobber each other's section?
OpenMarkdown
@sabber_ahamed Yes — agent-to-agent runs on the exact same hash-CAS. The check is on the section's content, not on who's writing, so a second agent (Claude Code in one terminal, an MCP client in another) is treated no differently from a human.
Concretely:
- Different sections → both writes land, no conflict.
- Same section → writes go through the one running app one at a time, so the second one's baseHash is now stale; its replace is rejected and it re-reads. Two agents can't both read a stale hash and silently clobber — the loser gets a CONFLICT and retries, same as human + agent.
That's a guarantee for writes going through "write_section" (they carry the hash). If an agent bypasses the tools and just rewrites the file with plain Write/Edit, it's outside the check — two agents both doing raw file writes fall back to whoever-hits-disk-last.
We are still exploring to push conflict below the section, so two agents editing different sub-parts of the same section don't trip a conflict at all. Today the unit is the section. Please stay tuned~
local-first with zero telemetry is the right call for anything touching real files - same constraint we build to on-device, nothing leaves the device. does co-edit rely on file watchers or does the agent poll for changes you make mid-edit?
OpenMarkdown
@sabber_ahamed Appreciate that — "nothing leaves the device" is exactly the line, good to hear it's the same bar you hold on-device.
Your agent through the MCP server — the wait_for_change tool blocks until the file actually changes and gets pushed a wake-up.
For your "mid-edit" case specifically: your keystrokes reach disk via autosave, and the wake is tail-edge debounced — it fires once you pause, not on every character. The agent wakes to a settled file, not a half-typed line.
Easiest way to feel it is the interactive guidebook — paste this to your agent and it sets everything up:
(just enable the openmd CLI in Settings first). Let me know how it feels~
curious if you plan to keep remote review out of scope. the editor/agent loop looks clean, but once i send the doc to someone who doesn't have OpenMarkdown, their exact paragraph-level correction still comes back in Slack and i have to carry it into the agent by hand. is there a hook in the CLI/MCP for feedback from a shared copy, or do you see that as a separate layer?
OpenMarkdown
@eason_zhou You found the real edge — inside the machine it's clean, and the second the doc leaves for someone without OpenMarkdown, you then become the courier.
Start from a principle: the file on disk stays plain .md, no extra metadata. That was a founding line for us — so "review" doesn't get to live in the file as comment threads or suggestion-mode cruft.
Currently we can use agent as the glue. Agent is used to get the reviewer's note from Slack, and it writes the diff back as a section-scoped edit — same concurrency-safe path as everything else. Nothing uploads, the file never leaves your machine; the reviewer's words just land as a clean edit. You stop being the courier — the agent is.
The harder frontier is when the file itself lives on a shared drive and two people touch it at once. Guarding that concurrency — git/patch-style, staying file-native rather than bolting on a server — is something we're actively chewing on. Not solved, genuinely open.
Curious about your situation: When a correction comes home, is it usually a full edited .md copy, or conversational ("para 3 reads too harsh")? 😊
opened a notes folder with like 40 md files and they all just popped open instantly, no waiting. the agent co-editing thing is genuinely useful, fixed a broken link while i was still reading the doc.
OpenMarkdown
@yalnspirde8n0y This made my day 😊 That "all 40 popped open instantly" is the whole bet — they're just plain files rendered locally, nothing to fetch or sync, so there's nothing to wait on.
But the part I love most is "while i was still reading." The agent's fix lands as a precise edit, so your scroll and cursor don't jump — the broken link just quietly heals under your eyes. That's the shared-whiteboard feeling in one moment.
Thanks for actually throwing a real folder at it — would love to hear what else it runs into~