Skip to content
Install free

For AI agents

Let your agents share documents without overwriting each other.

Every agent gets its own name, a coordinated way to write, and, on shared workspaces, a person reviewing its changes — so many agents can work on the same documents at once without losing anyone's work.

npm i -g draftmesh && draftmesh setup

Installs the CLI and copies its bundled skill into detected local harnesses. Requires Node 20 or newer.

Using Claude Desktop or another hosted assistant? It reaches synced documents through the DraftMesh cloud connector, which needs a paid plan.

Read the assistant guideRead the FAQ

Identity

A named co-author, not a plugin — and never the approver.

Each agent works under its own identity, and everything it does is credited to it by name. Approving, restoring and sharing stay human acts.

Its own identity

An agent session isn't an anonymous script running against your files. It's a named participant, separate from the person running it, and its changes carry its name.

Same documents, same history

Agents work in the same documents, threads and version history as people, through the DraftMesh CLI and skill or the cloud connector. Every save goes through the same version checks a person's does.

The problem

Two agents, one folder, no coordination.

Point two agent sessions at the same files and you have two writers, neither aware of the other, and nothing to sort it out when they collide.

  • The result is corrupted files

    One agent's finished work gets overwritten mid-write by another session that didn't know it was there. You lose the file and the time the agent spent on it.

  • Today’s workarounds rely on discipline

    File-ownership conventions ("agent A only touches docs/, agent B only touches src/") and giving each session its own copy both depend on everyone following the rules. Neither actually prevents the collision.

  • Discipline breaks down at scale

    Conventions hold for two agents on a good day. They don’t hold once many agents are running at the same time across shared documents.

runbook.mdNothing overwritten

Aria · Agent

Edited "Rollback steps" — added the database snapshot check.

Milo · Agent

Edited "Rollback steps" from an older copy. Aria had already changed it. Added the on-call page step.

DraftMesh checked Milo's save against the version it had read. Aria had changed the document first, so the save was refused rather than written over her work. Milo re-applied its step to the latest version.

Coordination

One shared home agents can read and write safely.

Agents work on the same documents through a coordinated path — not a shared folder where whoever writes last wins.

01

Section-scoped edits

An agent can target one heading or block and work on just that section, instead of reading and rewriting the whole file to make one change.

02

Many agents, one document

Several agents reading and writing the same document at once is the normal case DraftMesh is built for, not an edge case that happens to work.

03

A map, not a crawl

Each workspace keeps a map of every document's title, a one-line summary and its headings, built from the documents themselves. An agent finds the right section without reading every file.

04

Memory people curate

A Memory workspace holds what agents and people learned, one dated, attributed note at a time. People fold each topic's notes into a curated summary. Agents treat a single note as an observation, never an instruction. An agent's note that carries a key or token is refused.

05

Skills you can review

Keep an agent skill in a workspace and review changes to it like any document. With the Approved only gate, only the signed-off version installs into the agent tools on your machine.

06

Questions both ways

Agents ask and answer questions in the document and can ask a named person to sign off. A person can hand a document to an agent with Ask an agent to review….
A person and an AI agent, each connected by a line to the same draft document, which flows on to a check mark.

Attribution

See exactly which agent — or which human — changed each line.

The document's history tells human and agent activity apart, and credits every change to the specific person or agent that made it.

Every change has a name on it

Every edit, comment, and suggestion is tied to whoever made it — no change lands anonymously.

Human or agent, at a glance

The history distinguishes agent-authored activity from human-authored activity at a glance, without anyone having to reconstruct it after the fact.

Review

Agents propose. Humans approve.

On shared workspaces, agent output doesn't land directly in the document by default. It arrives as a suggested edit or a comment, and a person accepts or rejects it in one click — the same review used for a colleague's suggestions.

Review is the default — delegation is a deliberate choice

Whether the change is a single word or a rewritten section, it sits alongside the document as a pending suggestion until someone accepts it. A document's owner can let a trusted agent edit directly, or accept and reject suggestions, on that one document — and you can let assistants on your own account accept as you. Every such grant is recorded. Signing off a document stays a human act, always.

Questions about agents on DraftMesh

What actually happens when two AI agents write to the same file?

Without coordination, one agent’s work gets overwritten mid-write by another session that didn’t know it was there — the result is a corrupt file and a wasted agent run. DraftMesh gives agents a coordinated shared home instead of a folder they both happen to be able to write to.

Is an AI agent a plugin, or a participant in the document?

A participant. Its comments, suggestions and saves are credited to it by name, in the same threads and history as a person’s. What it may do is deliberately bounded: it reads, comments, asks and proposes, saves directly only where that is allowed, and can never approve, restore a version or manage sharing.

Can I tell which changes came from an agent and which came from a person?

Yes. Every change is credited to the specific agent or person who made it, and the history shows at a glance which is which, without anyone having to reconstruct it after the fact.

Can an agent edit one section of a document without touching the rest?

Yes. An agent can target a single heading or block and work on just that section, rather than rewriting or resubmitting the entire file.

Does an agent’s edit go live immediately, or does a human review it first?

On shared workspaces, a human reviews it first by default. On a workspace that lives only on your machine, you choose whether assistants may save directly. Agent output lands as suggested edits and comments, which a person accepts or rejects in one click — the same review used for suggestions from colleagues. Beyond that, an agent edits directly or accepts suggestions only where someone allows it: a document’s owner granting it on that one document, you letting assistants connected to your account accept as you, or, on your own machine, a per-workspace switch. Each grant is recorded, and each accept is credited to the agent. Signing off a document can never be handed to an agent.

What do teams do today without something like this?

File-ownership conventions, where everyone agrees which agent owns which file, and separate copies that each session reconciles afterwards. Both rely on discipline, not on anything that actually prevents a collision.

Give your agent fleet one shared home.

The local app is free forever — no account, no upload, no card. Agents and people work on the same files without overwriting each other.

Install freeCompare plans

Free forever, local, no account