For thirty years, concurrency was somebody else's problem. Two users changed the same record, the database quietly picked a winner, and everyone moved on. The referee was so dependable that most teams forgot a game was being officiated at all.
At the edge, that referee is gone. And the AI agents taking the field do not wait their turn.
The safeguard nobody noticed they relied on
Ask most teams how their software handles conflicting writes and the honest answer is that it doesn't. The database does. Locks, transactions, and isolation levels are promises the database makes so the application never has to think about them. That deal is what made the last three decades of software feel simple.
The deal worked because there was one database, in one place, with one clock. Every change eventually passed through a single point that could put the world in order. Concurrency was never truly solved. It was delegated. What looks like hard-won engineering intuition is, for most teams, trust in a referee they have never had to work without.
Edge AI removes the referee
Now picture ten AI agents on ten devices changing the same data at once. Some are offline. Some sit on different networks. Some simply move faster than the sync cycle. There is no shared clock, no lock that reaches across devices, and no single point every change passes through.
Every familiar concurrency tool assumed that point existed. Remove it and nothing steps in to replace it. The usual workarounds only rebuild the problem. Elect one device as the referee and you have recreated the single point of failure, and it still cannot hear the devices that are offline. Split the data so each agent owns its slice and conflicts vanish, right until two agents need the same record, which is the entire reason to run more than one.
Why agent conflicts are harder than human ones
It is tempting to say collaborative editing already solved this. It did not, because AI agents change the picture in five ways:
- Speed. Agents write at machine speed. Two of them overlap constantly, not occasionally. The rare collision becomes the normal state.
- Volume. Multi-agent means many writers: the thermostat, the door, every phone, a fleet of drones editing one map. Every new writer multiplies the odds.
- Autonomy. An agent reads data and then acts on it. A stale read becomes a real action taken on a false belief, and the mistake lands somewhere outside the database.
- Silence. When two agents collide, nothing fails. No error, no alert. The system just behaves strangely hours later, in a way nobody can reproduce.
- Physical stakes. In a shared document, a lost change costs a paragraph. At the edge, one agent locks the door for the night while another opens it for a delivery, in the same second. The collisions now happen where the physical world is.
The worst of these failures are not loud. They are polite. Every log shows every agent doing exactly what it was told, and the defect surfaces three days later in a place no one touched.
What a real concurrency model requires
There is prior art for life without a referee, and its lesson is clear: whatever resolves a conflict has to live inside the data itself, not above it. Four properties are non-negotiable:
- Every write is safe to make on its own, with no permission from any other device.
- Every conflict resolves the same way on every device, with no server or human adjudicating.
- No write is ever silently thrown away.
- Every device reaches the same final state regardless of the order updates arrive.
Notice what is missing from that list: a coordinator. These are the properties of data that knows how to merge itself, the idea behind conflict-free data types. Being deterministic is not the same as being right, though. Whether a door should end the night locked or open is a policy decision, not a data-structure one. The model's job is to surface that choice and apply it identically everywhere.
This is also why conflict handling cannot be bolted on later. Retry loops, write queues, and sync flags are attempts to rebuild the old referee out of duct tape. Conflict resolution either lives in the data model or it does not exist. And "last write wins," still the default in many production databases, is not a strategy at all. It is a data-loss policy with a friendly name, tolerable only when the cloud was the sole writer and the device just watched. In a world where every device runs an agent and every agent writes, it is a bug waiting for a bad day.
Built for the agentic edge
Edge AI already moved the models out of the datacenter. The writes went with them, and the old assumptions did not survive the trip. Handling simultaneous action without a coordinator is not a feature to add later; it is the foundation edge data management now has to start from.
At Source, we are building DefraDB, a distributed database designed for the agentic edge, where conflict resolution lives in the data and no referee is required.
