Agents gone stale

AI agents are getting better at doing useful work independently, but we will experience problems when many of them start working at tasks shared.

Most software today assumes a relatively simple model with a user that reads some state, makes a change, and writes it back. Even collaborative software designed for many humans is built around relatively short cycles of reading, editing, and committing state. Agents can instead work for minutes or hours while the world around them keeps changing.

A single application might soon have several agents running simultaneously, alongside humans, all reading and changing the same underlying state. A coding agent updates an implementation while another rewrites the API it depends on. A sales agent prepares a proposal while someone changes the pricing model. An operations agent starts fixing an incident based on infrastructure state that another agent has already modified.

Imagine Agent A reads a customer record and begins a long task. While it is working, Agent B or a human change that customer record. Agent A does not necessarily touch the same field when it eventually acts. It might update a proposal, send an email, modify another database record, or change a piece of code. There is no direct write conflict.

The action can still be wrong because the reasoning behind it was based on a world that no longer exists.

This makes agent concurrency different from simply giving every agent its own file, branch, task, or workspace. Separating where agents write reduces collisions, but it does not separate what their decisions depend on. Two agents can make completely different changes while still interfering with one another through shared assumptions.

The longer an agent works, the worse this gets. An agent might spend minutes researching, generating code, calling tools, or waiting on external systems. Every additional second creates another opportunity for the state it originally observed to change and humans make this even more complicated.

A person might interrupt an agent, change a requirement, edit the underlying data, or make a decision while several agents are already executing. That human action should become the new truth immediately. But unless the system knows which agents depended on the old truth, those agents may continue working toward an obsolete goal. This is why messaging between agents is simply not enough.

Agents can tell each other what they are doing, but conversation does not provide concurrency control. Messages can arrive late, be ignored, be misunderstood, or become stale themselves. The system needs a more fundamental mechanism for connecting what an agent observed, what has changed, and what it is still allowed to commit.

Traditional distributed systems already provide some of the building blocks: locks, leases, version numbers, conditional writes, ownership, transactions, and conflict detection. Agent systems need these too, but agents add another layer.

A database can tell you that a value changed from version 7 to version 8. It cannot necessarily tell you whether that change invalidates the plan an agent generated while looking at version 7. This requires tracking dependencies and intent.

If an agent reads ten pieces of state before deciding what to do, changes to any of those inputs may matter. Some changes should invalidate the entire task. Others should only require a small adjustment. Others may be irrelevant. Detecting the change can be deterministic. Understanding what the change means is much harder. The architecture for multi-agent systems therefore starts to look less like a collection of chatbots and more like a distributed transaction system.

Agents should be able to reason in parallel. But before their actions become authoritative, the system needs to know whether the assumptions behind those actions are still valid. When they are not, agents should be notified, re-read the relevant state, repair their plans, or escalate genuinely ambiguous conflicts to a human. This changes what "agent collaboration" means.

The challenge is not primarily getting agents to talk to each other. It is ensuring that hundreds of independently reasoning actors can share a changing world without silently operating on different versions of reality.

As agents get faster and more autonomous, coordination becomes part of the correctness of the system itself.

The next generation of software will need to know who is acting on it, what they believed when they started, what changed while they were working, and whether their next action is still valid.

We are building Ablo to solve this problem.