Memtrace · the coordination layer Coordination · live inside Memtrace

Fleets of agents that stop stepping
on each other.

Fleet is how Memtrace coordinates fleets of AI coding agents working on the same codebase. Agents say what they're about to do, before they do it. The broker sees overlaps coming, picks the safest path, and auto-merges 9 out of 10. Humans only get pulled in when a real decision has to be made.

Plug in your fleet

+40%dev productivity

−94%conflicts

90%auto-resolved

11MCP tools, agent-ready

Fleet · live broker · 4 agents

2 intents

1 overlap

01 · The new failure mode

The model isn't the problem. The fleet is.

Allie K. Miller (#1 most-followed voice in AI business) has documented her workflow: multiple Claude Code instances running simultaneously, each with filesystem access. Software teams will run fleets, not single agents, within 12 months.

Without coordination

Each agent starts cold

Re-reads files. Contradicts decisions another agent made an hour ago. Two agents editing the same function silently overwrite each other.

Without coordination

Merge time is too late

Three agents doing related refactors → conflicts that take humans hours to reconcile. The git tooling was designed for two engineers, not twelve agents.

With Fleet

Agents announce intent

Before editing, every agent calls publish_intent. The broker classifies overlaps against the live code map and chooses the safe path.

With Fleet

Cost gravity, not enforcement

Cooperation is cheaper than collision. Agents that ignore the protocol pay the cost in token waste and merge conflicts. The fleet self-selects.

02 · How overlaps get resolved

Three kinds of overlap. Two get auto-merged.

Every declared intent goes into one of three buckets. The broker decides which based on the structural delta: does this change add, modify, or break existing code?

Class A · additive Auto-merge

New code, no overlap with existing

New files. New functions. New tests. The change doesn't touch what anyone else relies on, so the broker accepts it instantly regardless of who else is working.

Example: agent/δ adding a new test in cart/totals.spec.ts while three others edit auth.

Class B · modification Auto-resolve

Two agents change the same thing

The broker picks the most recent intent and gives the other a heads-up with the winning change attached. The losing agent replans against the new state, no merge conflict.

Example: agent/α and agent/β both modifying rotateToken(). β replans on top of α's version.

Class C · destructive Ask a human

The change breaks the contract

An agent wants to delete a function or change its signature in a way that breaks callers. The broker stops the change and surfaces a clean conflict report. This is the only case a human is involved.

Example: agent/γ wants to remove the userId parameter from verifyJwt while six other agents call it.

03 · Watch it run

Two engineers. Two agents. Same file. Zero merge conflicts.

A live broker log from a real fleet. Two agents touch auth/session.ts at the same time. The fleet sees the overlap, picks the safe way through, both branches land clean.

What the broker does

Every line below is a real message from the broker on a fleet run. It receives intents, checks the code map, classifies overlaps, picks a resolution verb, seals the episode in MemDB.

agent declarations

overlap detected

resolution chosen

branches sealed

broker log · live

04 · The integration surface

11 MCP tools. Built into Memtrace.

No shell wrapping. No git hooks. No kernel-level setup. Memtrace auto-registers as an MCP server, so the integration is identical for any MCP-compatible agent (Claude Code, Cursor, Codex, Gemini CLI, Windsurf).

The MCP tool surface · live inside Memtrace

11 coordination tools

Intent publish_intent Declare upcoming edits. Returns the conflict report and propagation set.

Memory record_episode Record a completed change as a recallable event in MemDB.

State get_node_state Current state of a graph node (and its history), point-in-time aware.

Presence get_active_intents All currently-active intents from any agent in the fleet.

Reactive subscribe_node Long-poll for changes to a specific node. Reactive coordination.

History replay_history Point-in-time query against the episode store. Built on MemDB.

Impact query_propagation Which nodes were affected by an intent: the blast radius.

Cleanup cancel_intent Release an active intent. TTL-based GC catches abandoned ones.

Lease acquire_lease Exclusive lease over a set of nodes for the duration of an edit.

Lease release_lease Release a held lease.

Lease renew_lease Extend an active lease beyond its initial TTL.

05 · Measured at fleet scale

1,000 tasks · 30 overlap zones · measured wallclock.

Methodology: identical 1,000-task workload, run twice: once siloed (no coordination), once with Fleet. Same model (Claude Haiku 4.5), same dataset, 30 hand-built overlap zones across 38 intent kinds. Result JSONs in the public repo.

Wallclock reduction

−38%

Coordinated fleet finished 1,000 tasks in 62% of the siloed baseline's time. Same agents, same model, same tasks.

Auto-skip rate

90%

271 of 300 overlapping tasks resolved without an agent burning work. Pre-classified by the broker, no token spend.

Tokens saved

−26%

76.5M tokens coordinated vs 103M siloed. Cost: $16.34 vs $20.48 on the same workload.

Class C escalations

Out of 300 overlapping tasks. The only ones that actually needed a human decision. Down from 77 in the siloed run.

Plug in your fleet

Your engineers don't have to play referee.
It ships inside Memtrace. Your agents see each other.
9 out of 10 overlaps auto-resolve.
Humans get pulled in only when it matters.

Fleet ships inside Memtrace. It auto-registers as an MCP server. Drop the config into Cursor or Claude Code, run your fleet normally, and the broker handles the rest. Free during early access.

Plug in your fleet

Fleet · coordination · +40% · −94%