Your agents went multiplayer. Your backlog didn't.

You added an agent.

Now two things write to the codebase, and they remember different things.

Then three.

Each one plans in its own session. Each session ends.

Your backlog still thinks one person works at a time.

An assignee field. A status. Last write wins.

This is what happens next.

40% of the office workday is spent working with others. 39% alone.

Gensler asked 16,459 office workers in 16 countries how they spend their time. Fieldwork July to September 2025.

Half of knowledge workers have found another team doing the same project.

Atlassian, 5,000 workers, 2024. Self-reported, not measured hours.

More than 10 hours a week lost to organizational inefficiency, say half of developers.

Atlassian and Wakefield, 3,500 developers and managers, 2025. Their own estimate of their own week.

Coordination was the expensive part before anyone added an agent.

15×.

Year-over-year growth in active agents inside Microsoft 365, by Microsoft's own count. A growth signal, not a market size.

4.58 million to 6.73 million a day.

Average daily downloads of the official MCP SDK, March to August 2026. It rose every month. Installs and CI runs, not people.

Every new writer is a new memory. Nothing made them one plan.

In August 2026, Anthropic's red team let 30 agents build a game together.

No shared plan. Each agent chose its own next step.

18 of 30 picked the same branch name.

mvp-game-loop. Same task, same name, eighteen times.

In another run: 2.4 million job requests. 117 jobs accepted.

Giving the agents roles, or a CEO, "did not make much difference." Controlled experiments, not production data.

"Coordination doesn't naturally emerge from stronger intelligence nor alignment at the individual level."Anthropic, Frontier Red Team · August 13, 2026 · source

Two writers fix the same bug and find out a week later.

That is the human-scale version of the same experiment. It runs in every team that added agents without adding a plan.

Intelligence doesn't refuse a second taker. A record does.

The newest answer is the shared session: several people inside one agent's chat.

It works. Everyone sees the same conversation, steers it, hands it over with the context intact. Then the session ends, and the plan it held ends with it.

Even the best shared task list inside an agent is one team per session.

It locks a claim so two teammates can't grab the same task, and it gates on dependencies. It can't be shared across sessions, and when a task gets stuck, a person fixes it by hand.

The trackers your team actually shares are the other way around.

They outlive the session. But there the assignee is a label: the human stays the assignee, the agent is a delegate, and a second taker is never refused.

A plan your agents can't see isn't a plan.

If the record lives outside the editor, the agent plans from its own memory again. So does the next person who opens the task.

One tool refuses the collision and forgets by morning. The other remembers everything and lets it happen.

Ten grab it at once. One gets it. Nine are refused.

A claim is a single write the server accepts or rejects. The nine get a typed conflict back, not a silent overwrite. This is a contract test in Ophanimus Forge.

A hold that expires on its own.

A claim carries a heartbeat lease, 30 minutes by default, so a dead session releases its work without anyone noticing it died. Some roles hold without expiry. That is a policy, not an accident.

Blocked work can't be picked up.

A task whose dependencies aren't finished is refused, not warned about. "What's next" can only answer with what is actually ready.

And the record outlives the chat.

Claims, holds, skips and replans land in one graph that every person and every agent reads and writes, from inside their own editor.

A shared session makes one chat multiplayer. A record with rules makes the team multiplayer.

Call it an execution graph: the dependency graph of claimable work that people and their agents execute against.

It knows who holds each task, what is ready, what is blocked, and why the order changed. Forge enforces it and runs none of the work itself.

A context graph built afterwards from your tools describes the work.

It reconstructs relationships it never saw. It can't refuse a second taker.

An execution graph governs the work as it happens.

Every claim, skip and replan passes through it. So the reason gets written at the moment of the decision, not reconstructed a quarter later.

Skip a task on purpose and the record keeps the reason.

A deferral, a cancel, a change of priority: the reason is stored with the task, not in the meeting where it was said. It is still there a quarter later, next to the work it explains.

108,289 ranked choices. 1,543 decisions with a written reason.

Founder use, not customer data: what one person's backlog produced between March and September 2026 by running his own work through it.