What breaks when agents share task state

Nov 2026 · Explainer · 6 min read

Picture a plan with several branches and a handful of agents working through it overnight. By morning most of it is done. A function has been written in duplicate, a decision made on Tuesday has quietly been undone, and nobody can say why the last step was taken. Nothing crashed, and every agent did what it was asked. What failed was the state they shared.

By shared task state we mean the plan, its tasks and the decisions around them, read and written by multiple agents. This piece goes through the ways that tends to fail in a multi-agent workflow, and the practice that helps with each. Where we describe LatticeRun we say so and point to the page that backs it. The rest is reasoning about shared state, not a claim about any outside system.

Conflicting writes: the later write wins and nobody notices

The symptom. A task says something the agent that was working on it never wrote. Or branches of the work disagree, and each looks reasonable on its own. Often the first sign is a person asking why a finished piece of work has changed.

The mechanism. When several agents can change the same record, the last write is the one that stays. Each agent acted on a correct reading at the moment it read, so none of them did anything wrong. The record is where the mistake lives, because it has no rule about who may change what, and no agent is told that its work was overwritten.

The mitigation. Give every agent an ownership boundary before it writes anything, and make it declare that boundary. In LatticeRun an agent claims a branch before changing it and reports what it built. In Strict mode the server refuses task writes outside the claimed branch, and in Guided mode it corrects out-of-sequence work without refusing it. Agents can read the enforcement setting, but no agent tool can lower it. A rule that the agent itself can lower is only a suggestion, so the rule needs to sit where the writes happen.

Stale context: acting on a reading that has gone out of date

The symptom. An agent builds confidently on a decision that has since been reversed. Its output is internally sound and consistent with a plan that no longer exists.

The mechanism. Context is a snapshot. The longer an agent works from one, the older it gets, while the plan keeps moving underneath it. Nothing tells the agent what changed after it read, so it cannot know that its picture is out of date.

The mitigation. Put the refresh at a boundary the agent has to cross anyway. For LatticeRun that boundary is claiming a task: the agent receives the project brief, relevant Project Memory and a synopsis of the plan when it claims. Project Memory is bounded, so what arrives is relevant context rather than a full replay of everything that came before. Human decisions follow the same route. Each section of an artefact is approved, rejected or sent back with a note, and the agent sees the decision on its next claim. As a working practice, keep claims short and tied to a branch, because each new claim is a fresh reading.

Handoffs that lose the reason

The symptom. The next agent, or the next person, can see what changed but not why. It reopens a question that was settled, or removes a constraint that was there on purpose.

The mechanism. A handoff usually passes on outputs. The reasoning lives in a context window or a chat, and both are gone when the session ends. What is left is a result without its justification, and the next worker has to guess the justification or ignore it.

The mitigation. Write the reason down in the place the next worker will receive it. LatticeRun's Project Memory keeps decisions, guardrails, architecture, checkpoints and handoffs with the project, labelled proposed, approved or verified. The label matters in practice, because a reader can tell a settled decision from a suggestion. The agent handoff checklist goes through what a good handoff note contains.

Success reported without evidence

The symptom. A task is marked done and the person reviewing it finds nothing behind the word. The change is missing, partial, or not the one that was asked for. The report was confident and the work was not there.

The mechanism. In a shared workflow the agent's own report is often the only record that the work happened. A report costs the agent nothing to write, so it can be wrong without anyone having lied: the agent may be describing what it intended, or what it saw in its own context rather than in the project. If nothing sits between the report and the plan, the plan inherits the mistake and the next agent builds on it.

The mitigation. Ask for evidence at the point of reporting, and put a person or a second check between the report and the record. In LatticeRun an agent reports what it built when it finishes, and artefacts give a task a review thread where each section is approved, rejected or sent back with a note. As a working practice, a report that cannot point to something a reviewer can open, such as a link, a file or a change, is a claim and not yet a result.

Not knowing who is doing what

The symptom. A person looks at the board and cannot tell which agent holds which piece of work, or whether a piece is progressing or has stalled. Work is duplicated, or it sits because everyone assumes someone else has it.

The mechanism. Without a visible holder, a piece of work looks the same whether somebody is on it or nobody is. Claims are the answer, but a claim that nobody can see, or one that never lapses, creates the stall it was meant to prevent.

The mitigation. Make holding both visible and limited. Each agent holds one claim at a time, and Strict mode blocks new claims when the standing brief, agent.md, is overdue, which keeps that brief current. On the tree, a live pill shows which branch an agent holds and its sentence about what it is doing, and abandoned work shows as Blocked with the reason. The guide covers how claims work in practice.

What this adds up to

The changes that matter are about boundaries and records rather than smarter agents. Claim before writing. Hand over context at the claim. Ask for evidence with every report. Store reasons where the next worker will see them. Keep holding visible, and keep each holder's claim small. These work because they do not depend on every agent behaving well.

LatticeRun's MCP connector is available on paid plans, and the MCP page describes how an agent connects.

Frequently asked questions

What is shared task state?

It is the plan, its tasks and the decisions around them, read and written by multiple agents.

How do you stop agents overwriting each other's work?

Give each agent an ownership boundary before it writes. In LatticeRun an agent claims a branch before changing it. In Strict mode the server refuses task writes outside the claimed branch, and in Guided mode it corrects out-of-sequence work without refusing it.

Why does an agent act on outdated information?

Its context is a snapshot, and the plan keeps changing after the agent has read it. Refreshing at a boundary the agent has to cross, such as claiming a task, and keeping claims short, helps.

What should a handoff include?

The reason behind the work, not only the result. Project Memory in LatticeRun keeps decisions, guardrails, architecture, checkpoints and handoffs, labelled proposed, approved or verified.

Can an agent turn the enforcement off?

No. Agents can read the enforcement setting, but no agent tool can lower it.