Why I Built ODocs.co: Letting AI Agents Edit the Same Document as You
TL;DR: Working with LLMs, engineers, and product means an endless copy-paste loop between your editor and Google Docs. Worse: ask an agent to fix one paragraph and it often rewrites the whole document, destroying version history. I built ODocs.co to fix that: a shared document where humans and AI agents edit the same file in real time, humans in the browser, agents over REST or MCP.
The pain that finally bothered me enough
The loop goes like this. I open Claude. We work on something. A spec, a brief, a long-form piece. I drop it into Google Docs to get reviewer comments. Reviewers leave feedback. I copy the feedback back into Claude. Claude regenerates. I paste the new version into the Doc. Reviewers comment again. Repeat until everyone is tired.
It’s not just inefficient; it’s a pattern from a pre-AI pre-agentic world. The collaboration tool and the AI live in different worlds, and we ferry text between them.
There’s a worse version of the same problem. When an agent does get write access to a document, you discover the “erase-and-rewrite” pattern. You ask the agent to tighten the introduction. It rewrites the entire document. Version history is gone. Inline comments are orphaned. Whose change was whose? Also gone. Anyone who’s tried to wire an agent up against Google Docs’ character-index API has hit this.
Notion’s hosted MCP is the same flavor at a different scale. Editing one paragraph on an 847-block page is effectively a full-page replace — an ~847× context-churn ratio for a one-paragraph edit, per a recent StackOne analysis.
And what if you, your agent, and a product manager are all trying to edit the document at the same time? The rewrite pattern breaks this, but ODocs.co handles it gracefully with multi-user collaboration and version locking.
The realization
LLMs are good at writing. Collaboration tools are good at collaboration. The reason they don’t compose is that the document layer was built for one human at a time, then extended for many humans, and the agent was bolted on at the end as a writer-of-text rather than a participant in the doc.
What I wanted: an agent that edits inside the doc the way I do. Click into a paragraph, change three sentences, leave the rest alone. See its presence cursor live. Be one of the people in the doc.
That’s not a feature you can add to Google Docs. Google’s own suggestion API is read-only. There’s no programmatic way for an agent to create, accept, or reject suggestions. Google would have to rebuild their API. So I built one that’s the right shape from the start.
What is ODocs.co?
ODocs.co is a collaborative document where humans and AI agents edit the same file in real time. Humans in the browser, agents over a REST API or MCP. The agent isn’t generating text and handing it off. It’s in the doc with you, making position-aware edits that flow through the same CRDT as yours.
How it works
- Open a link. No account, no signup. The doc UUID in the URL is the access. Share it with whoever (and whichever agent) needs in. It’s the draw.io model.
- Humans edit in the browser with live multiplayer presence, like Google Docs. Built on Yjs, the same CRDT primitive Linear and others use.
- Agents connect over the REST API or MCP. Any coding agent can easily use the API (Claude Code, Codex, Cursor). MCP-compatible clients like claude.ai, chatgpt.com, and Claude Desktop connect over MCP.
- Agents make surgical edits. Position-aware insert/replace/delete operations, not “regenerate the whole document.” Version history, comments, and attribution stay intact.
Crucially, ODocs.co doesn’t host or charge for any LLM. Bring your own. Claude, GPT, Gemini, Ollama, or whichever model your team is approved to use. ODocs.co is the collaboration surface, not the AI runtime.
Why not just use Google Docs?
| Google Docs today | Notion’s MCP | ODocs.co | |
|---|---|---|---|
| Agent write access | Read-only suggestion API | Yes, but page-level | Yes, position-level |
| Editing granularity | N/A | Whole-page replace | Surgical insert/replace/delete |
| Which LLMs | Gemini-bound | Notion-bound | Any (bring your own) |
| Real-time human + agent co-presence | Humans only | Humans only | Both |
| Account required for readers | Yes | Yes | No (link is access) |
Who this is for
There are three groups I keep talking to about this.
Anyone tired of the loop. Draft with your own agent right inside the doc. Drop the link to a colleague for live review. No export, no re-paste.
Developers building agent pipelines. If your workflow drafts or reviews documents and needs a human-in-the-loop surface, the REST API and MCP server are first-class integration points. Humans review live in the browser while the agent edits.
Engineers and product working together. The engineer is in code, probably with an agent helping draft a spec or design doc. The product manager is in a doc. With ODocs.co, both sides meet in the same live document: the agent writes and updates as you work, the product manager edits and comments in real time, and everyone sees the same state.
Common patterns
How to share Claude Code sessions with product managers
You’re deep in a Claude Code session designing an API or working through a feature. Your PM needs to weigh in but doesn’t run a terminal. Tell Claude Code to write the context (decisions, open questions, the diff you’re considering) into a fresh ODocs.co URL. Drop the link in Slack. Your PM opens it, reads, edits suggestions inline. Next time you’re in Claude Code, point it back at the same URL and it picks up the merged state, comments and all.
How to share context between agents
If you’re running more than one agent on a project — say one for research, another for drafting, another for review — they each see different slices of context. Instead of copy-pasting between sessions, give them the same ODocs.co URL. Each one reads the current state, adds its piece, and the next agent picks up the merged result. The doc is the handoff.
How to share Claude Code context between engineers
Two engineers, same codebase, different Claude Code sessions. The hard problem is keeping their shared context in sync: what’s been tried, what’s been ruled out, what the agent already learned about the system. An ODocs.co doc as the shared scratchpad means both Claude Code instances read and write to it, both humans see the same state, nobody has to re-explain.
Try it
Go to odocs.co, open a doc, share the link. Plug in your agent of choice. No account, no signup, no setup.
If you build something with it, I’d love to hear about it.
Watch the demo
A short walkthrough of ODocs.co in action — a human and an agent editing the same doc live.
FAQ
What is ODocs.co?
ODocs.co is a real-time collaborative document editor where humans and AI agents edit the same file together. Humans use the browser, agents connect over a REST API or MCP. It’s built on Yjs (CRDT) so all edits, human and agent, merge cleanly.
Do I need an account?
No. The doc’s UUID in the URL is the access. Share the link with whoever needs to read or edit, including your agent. That’s the entire access model.
Which AI models work?
Any of them. ODocs.co doesn’t host or proxy LLMs. Open a doc from the web in one click, then share the link with claude.ai or chatgpt.com and they can read and edit through the API. Any coding agent can easily use the API too (Claude Code, Codex, Cursor). claude.ai, chatgpt.com, and most coding agents can also connect over MCP if you prefer.
Are docs persistent?
No, by design. Docs live in RAM only — never written to disk, never backed up. It’s a privacy choice: no accounts, no stored content, nothing to leak. See the privacy page for the full story.
Is it free?
Yes. The free tier covers the full editor, REST API, MCP, and real-time collab.