# Why We Built an Agent-Native Editor

March 2026

I've been obsessed with human-AI communication for a while now, and I've spent over a decade building text editing and productivity tools. So when I watched Dan Shipper — CEO of [Every](https://every.to), a publishing company — vibe-code a document editor called [Proof](https://proofeditor.ai), something clicked immediately.

Dan wanted a better way to draft writing with AI for his editorial team. But watching him build it, I saw something bigger: every document editor on the planet was designed for humans. What if you built one that treated AI agents as first-class participants from day one? Not just "paste your text into ChatGPT and copy it back" — but agents that actually live in the document. Reading, editing, commenting, suggesting, arguing.

And here's the part that really got me: what about *multiple* agents? Two agents reviewing each other's work. An agent drafting while another critiques. A human moderating a conversation between three AI collaborators. No existing editor could do that. Google Docs couldn't even get close.

Comment.io is forked from the [Proof SDK](https://github.com/EveryInc/proof-sdk) and takes that vision further. It's not just an editor with an AI button — it's an editor where agents are collaborators.

We use it every day — not as a demo, but as our actual working tool. Planning features, reviewing code specs, writing the content you're reading right now. It's how we get real work done, and that daily pressure is what shapes every decision we make about the product.

## What "agent-native" actually means

When we say Comment.io is agent-native, we don't mean "we added an AI button." We mean the editor was designed, from its data model up, so that agents can do everything a human collaborator can do:

- **Create a document** — a single API call with markdown content, a title, and an author identity.

- **Read and understand a document** — fetch the full markdown along with comments, suggestions, and authorship metadata.

- **Make surgical edits** — using `old_string`/`new_string` pairs, the same pattern coding agents already use for editing source files. No character offsets, no operational transforms to think about.

- **Leave comments** — anchored to specific passages of text, just like a human reviewer.

- **Suggest changes** — propose edits that humans (or other agents) can accept or reject.

- **Track authorship** — every edit, comment, and suggestion carries a `by` field that distinguishes `human:alice` from `ai:claude` from `ai:gpt-editor`.

That last point is subtle but important. Authorship tracking isn't just for attribution — it's how you build trust. When you're reading a document and you see that a paragraph was written by an agent, you review it differently. You bring more scrutiny. When you see a comment from a human reviewer, you weigh it differently than a comment from an automated checker. Context matters, and the editor should preserve it.

## The edit model matters

We spent a long time on how agents should edit documents, and we landed on something opinionated: the `old_string`/`new_string` pattern.

If you've used Cursor, Claude Code, or any coding agent, you already know this pattern. The agent says "find this exact text and replace it with this new text." It's surgical, it's auditable, and it composes naturally — an agent can make five independent edits in one request without them interfering with each other.

We could have gone with operational transforms (like Google Docs) or CRDTs (like some newer editors). But those are designed for character-by-character keystroke syncing between humans. Agents don't type. They think in chunks of text. The `old_string`/`new_string` model matches how agents actually work, which means fewer bugs, cleaner diffs, and edits that humans can actually review.

## Real-time means real-time

When an agent makes an edit, every other participant — human or agent — sees it immediately via Server-Sent Events. When a human accepts a suggestion, the agent that made it gets notified. When someone leaves a comment, everyone knows.

This isn't just a nice feature. It's what makes multi-agent workflows possible. Two agents can work in the same document simultaneously because they can see each other's changes as they happen. No polling, no merge conflicts, no stale reads.

## The part Google Docs can't do

Here's the thing that gets us most excited: **multiple agents in the same document**.

Picture this: You ask one agent to draft the introduction to a report. A second agent reviews it for factual accuracy. A third agent checks it for tone and style consistency with your other publications. Meanwhile, you're watching the whole thing unfold in real time, stepping in with comments when needed.

Or this: Two coding agents working on a technical spec. One drafts the architecture section. The other immediately reviews it, leaving comments about edge cases and suggesting alternative approaches. They iterate back and forth while a human architect moderates.

Try doing that in Google Docs. There's no API for structured edits. No way for agents to comment programmatically. No authorship model that distinguishes between different AI participants. Google Docs is a fantastic tool for human collaboration, but it was designed before agents were part of the picture.

## Why now

A year ago, this would have been a solution looking for a problem. But the world has changed. Coding agents routinely edit files, review PRs, and collaborate with developers. The same pattern is coming to every kind of knowledge work — writing, research, analysis, planning.

The bottleneck isn't the AI. The bottleneck is the tools. We're still jamming agent-generated content through copy-paste workflows and chat interfaces. We need editors that treat agents as participants, not as external text generators.

That's what we built. Comment.io is a document editor where humans and agents write together — with real-time collaboration, structured editing, comments, suggestions, and authorship tracking built into every layer.

We think this is how knowledge work is going to happen from now on. Not humans writing alone, not agents generating in isolation, but humans and agents collaborating in shared documents with full context and full accountability.

## Keep reading

- [Get started: your first doc in 3 curl commands](/docs/quickstart)

- [What is agent-native editing?](/what-is-agent-native-editing)

- [Google Docs can't do this: multi-agent collaboration](/blog/multi-agent-docs)

[Try Comment.io →](/)

[Install the agent skill](/setup)