OpenMarkdown

A markdown editor you and your agent co-edit

Productivity

Notes

Developer Tools

Visit WebsiteSee on Product HuntTwitter ⧉

Per-section undo landing next update is the one I'd wait for. The redo-just-section-3 workaround still routes through another model call, and while it re-runs the mangled version sits live in my file, so if I get pulled away I might ship it. A local Cmd-Z scoped to one section of that transaction skips the round-trip. One thing I'd want to know: does the redo reliably touch only section 3, or can it drift into the two good sections since they came in as the same diff?

Co-editing with an agent in the same document (rather than a separate chat panel) is a genuinely different interaction model — most AI writing tools still keep you and the model in separate spaces. How are you handling conflict resolution when both a human and the agent want to edit the same section at roughly the same time? Curious if there's a locking mechanism or something more like real-time merge.

Optimistic concurrency with a read-hash and reject-retry instead of last-write-wins is exactly the answer I was hoping for. One follow-up on the retry path: if I'm typing continuously in the same section while the agent keeps getting rejected, does it back off or eventually give up, or can it spin retrying against a section that never settles? And is that read-hash scoped to the whole section or something finer, so a 500-line section doesn't reject agent edits that don't actually overlap my cursor?

The line I keep coming back to is buried near the bottom: that you use it as your default $EDITOR for composing Claude Code prompts so you don't mis send a half written message.

That is a sharper wedge than the co-edit story above it. Everyone shipping an agent editor is arguing about merge semantics, and this thread shows you can hold your own there. But nobody has touched the fact that the prompt box in a coding agent is a terrible place to write anything longer than a sentence. No undo, no drafts, and an enter key that fires early. Anyone using Claude Code daily feels that friction and has never once thought to point $EDITOR at it.

Worth asking whether that belongs in the tagline rather than paragraph nine. The local first stance is doing quiet work here too, no account and no telemetry is a real reason to keep it open all day.

Local-first with agent co-editing through MCP is a smart wedge — most agent-editor integrations force you into someone's cloud. We live in markdown files all day (our agents keep their working memory as .md docs), so an editor where the human and the agent are first-class co-editors of the same file is genuinely useful. How do you handle conflicts when the agent writes while I have unsaved edits in the buffer?

Most of this thread stress-tests the co-edit on code and CLAUDE.md, but the case I care about is prose. When I'm drafting an essay and the agent reworks a paragraph I'm mid-sentence in, the merge is the easy part — what I actually lose is voice. Agents tend to iron my phrasing into that smooth, averaged register, and because it lands as a clean diff in my own buffer it's easy to accept without noticing my sentences stopped sounding like me. Have you thought about surfacing agent-authored ranges differently from mine — a subtle tint, or a "written by agent" gutter mark — so I can see where my words end and the agent's begin before I commit? Local-first and rendering inline in the same pane is exactly the right foundation for real writing, not just notes. Nice work.

Local-first and I can use my own agent? That sounds pretty awesome... that really lovely UI is the icing on the cake for me. :)

Cursor and undo surviving is the big one, thanks. The follow-up that actually matters for me is undo granularity: when the agent's rewrite touches three sections at once and you apply it as one precise diff, is that one undo entry or three? The case I keep hitting is the agent nails two sections and mangles the third, and I want to Cmd-Z just the bad one without losing the two good edits. Does openmd split the applied diff into per-section undo steps, or is it atomic?

Opened a few of my old notes and the instant load felt surprisingly snappy. Loved that my agent can drop edits straight into the file without any setup.

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.

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?

The write_section path is the clean answer, but the direct-file-write path is the one I hit most, since Claude Code and Cursor both grab their own Write/Edit before any project MCP. On that path, when the agent rewrites the whole file, does openmd diff it back down to section granularity so my undo history and cursor survive, or does the buffer reload as one big edit? That reload is what actually loses my place mid-sentence.

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?

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?

Keeping the Markdown file as the source of truth while allowing section-scoped agent edits is a strong design choice. How are you thinking about provenance—showing which passages came from the user versus the agent after several rounds of co-editing?

The co-editing angle is the interesting part. The section-scoped hash-CAS approach makes sense for simple edits, but OT and CRDTs usually struggle with the same edge case: an agent producing a large structural rewrite while a user is mid-sentence in that region. Does it fall back to last-writer-wins, or is there a way to express intent at finer granularity than section level?

a co-editing markdown tool is a really clean idea, I've had too many docs where an agent's edit and mine collide and one of us silently overwrites the other. does it show live cursors/diffs while the agent is writing, or do you only see the change after it commits its edit?

The concurrency answers here all assume the agent sends a small edit, but in practice most coding agents rewrite the whole file even for a one-line change. When an agent edited a CLAUDE.md I was mid-sentence in, the pain wasn't a merge conflict, it was losing my cursor position and undo history to a wholesale rewrite that section-level hash-CAS still treats as one big dirty region. Do you constrain the agent to patch anchored ranges, or accept a full write and reconstruct the minimal diff yourself?

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.