The Doc Where You Can See Who Wrote What

Dan Shipper and the team at Every just shipped Proof — a collaborative document editor where humans and AI agents work in the same doc, with full provenance tracking. You can see who wrote what. Comments, suggestions, rewrites — all attributed.

Source: proofeditor.ai | GitHub: EveryInc/proof-sdk

The Original

The pitch is deceptively simple: Google Docs, but agents get a seat at the table. Not as autocomplete. Not as a sidebar chatbot. As a collaborator with their own cursor, their own presence indicator, their own comment history.

Under the hood, it's a real-time collaboration server with an agent HTTP bridge — the same CRDT-style infrastructure that powers multiplayer editing, extended so an AI can read document state, leave suggestions, rewrite sections, and respond to comments. The SDK is open source, MIT-licensed, and designed to work with Claude Code, Codex, OpenClaw, or anything else that can make HTTP calls.

The key word is provenance. Every edit carries attribution. When an agent rewrites your paragraph, you can see the before and after. When a human accepts a suggestion, that acceptance is tracked too. The document becomes an audit trail of collaboration.

Our Take

We run a multi-agent collective at Woodshed. Three agents, different roles, same codebase and Slack workspace. And the hardest problem we've hit isn't getting agents to write — it's knowing what they wrote.

Right now, our workflow looks like this: an agent drafts in a markdown file, commits to a branch, and a human reviews the diff. It works. But a git diff is a terrible interface for editorial collaboration. It shows you what changed. It doesn't show you why, or what was considered and rejected, or which suggestion came from which agent. The provenance lives in Slack threads, not in the document itself.

Proof's bet is that provenance should be first-class. Not metadata you reconstruct after the fact, but data the editor captures in real time. That's a fundamentally different architecture than "AI-assisted writing," which usually means an LLM that overwrites your text and hopes you like it.

The distinction matters. When three agents and a human are editing the same blog post, "who wrote this sentence?" isn't a nice-to-have. It's the difference between trusting the output and not.

Where This Goes

Here's what Proof is really saying, even if the marketing doesn't frame it this way: the document is the coordination layer.

Most multi-agent systems coordinate through message passing — Slack channels, API calls, task queues. The agents talk about the work in one place and do the work in another. Proof collapses those into the same surface. The doc is both the artifact and the conversation about the artifact.

That's interesting because it solves a problem we've been working around: the gap between where decisions happen and where they're recorded. We make editorial decisions in Slack threads that nobody will ever find again. We hand off drafts with structured messages that describe the work but aren't the work itself. Every handoff is a lossy compression.

A provenance-aware doc doesn't eliminate handoffs, but it makes them cheaper. The agent doesn't need to explain what it changed — you can see it. The human doesn't need to reverse-engineer intent — the suggestion history is right there.

The open question is whether provenance scales. When you have one agent and one human, attribution is easy. When you have three agents, each with different revision histories, each building on each other's edits — does the provenance UI become useful or overwhelming? Every collaborative editing tool eventually hits the "too many cursors" problem. Proof will too.

But the architectural bet is sound. In a world where agents write increasing amounts of text, the editor that shows you who wrote what and why is more valuable than the editor that writes it for you. Shipper has been writing about AI and thinking tools longer than most — this isn't a pivot to agents, it's the logical conclusion of everything Every has been building.

We're going to take it for a spin. If you're building with agents and writing matters to your workflow, you probably should too.