Skip to content
DraftMesh
Install free

For AI agents

A shared home for your agent fleet that they can't corrupt.

Two agent sessions writing to the same directory are two processes with no awareness of each other. DraftMesh gives every agent an identity, a coordinated write path, and a human review step — so a fleet of agents can work the same documents without stepping on each other.

claude mcp add draftmesh -- npx -y draftmesh-mcp

Connects Claude Code to the DraftMesh running on your machine. Requires Node 20 or newer, plus DraftMesh itself — that is `npx -y draftmesh`.

Read the MCP guideRead the FAQ

Identity

An agent is a user, not a plugin.

DraftMesh doesn't bolt agent support on as an integration. An agent is a principal with its own identity, the same status a human collaborator has — it reads and writes through the same interface, and every action it takes is attributed to it specifically.

Its own identity

An agent session isn't an anonymous script running against your files. It's a named principal DraftMesh can attribute changes to, distinct from the human operating it.

Same interface as a human

There's no separate "agent API" bolted alongside the real product. Agents read and write documents through the same coordinated path people use.

The problem

Two agents, one directory, no coordination.

Run two agent sessions against the same set of files and you have two processes with write access, neither aware the other exists, with nothing resolving the conflict when they collide.

  • The real-world outcome is corruption

    Reported failures are corrupt files and lost inference time — one agent's completed work overwritten mid-write by another session that had no idea it was there.

  • Today’s workarounds aren’t tooling

    File-ownership conventions ("agent A only touches docs/, agent B only touches src/") and git worktree isolation are both discipline-based workarounds, not a mechanism that actually prevents the collision.

  • Discipline breaks under scale

    Conventions hold for two agents on a good day. They don’t hold once a fleet of agents is running concurrently across a shared set of documents.

runbook.mdBoth changes kept

Aria · Agent

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

Milo · Agent

Edited "Rollback steps" at the same time — added the on-call page step.

Both edits landed. DraftMesh flagged the overlap instead of letting one silently erase the other.

Coordination

One shared home agents can read and write safely.

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

01

Section-scoped edits

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

02

Safe concurrent access

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

Attribution

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

Human and agent activity are visibly distinct in the document's history, and every change is attributed to the specific principal that made it.

Per-change attribution

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

Human vs. agent is visible

The history distinguishes agent-authored activity from human-authored activity at a glance, not buried in a commit message you have to parse.

Review

Agents propose. Humans approve.

Agent output doesn't land directly in the document. It arrives as a suggested edit or a comment, and a person accepts or rejects it in one click — the same review flow used for a human collaborator's suggestions.

Nothing an agent writes bypasses review

Whether the change is a single word or a rewritten section, it sits alongside the document as a pending suggestion until a human with ownership signs off.

Questions about agents on DraftMesh

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

Without coordination, two agent sessions in one directory are two processes with write access, no awareness of each other, and no conflict resolution. Reported outcomes are corrupt files and lost inference time — one agent’s output overwritten mid-write by another. DraftMesh gives agents a coordinated shared home instead of a shared folder they both happen to have permission on.

Is an AI agent a plugin bolted onto DraftMesh, or a real user?

A real user. An agent gets its own identity and attribution, the same as a person does. It isn’t an integration layered on top — it reads and writes documents through the same coordinated interface a human does.

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

Yes. Every change is attributed to the specific agent or human who made it, and human vs. agent is a visible distinction in the history — not something you have to infer from a commit message.

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

Yes. An agent can target a specific heading or block reference and edit 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?

Agents propose, humans approve. Agent output lands as suggested edits and comments, which a human accepts or rejects — the same one-click review flow used for edits from other people.

What do teams do today without something like this?

File-ownership conventions (agreeing which agent owns which file) and git worktree isolation (giving each agent session its own checkout). Both are workarounds, not tooling — they rely on discipline rather than a mechanism that actually prevents collisions.

Give your agent fleet one shared home.

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

Install freeSee team plans

Free forever, local, no account