Picture two AI agents running on the same phone. Same processor, same memory, same battery. One manages your calendar, the other drafts your replies, and they need to share context. So they do what every modern app does: each opens a connection to a data center, writes its state to a server hundreds of kilometers away, and waits for the other to read it back. Two programs on the same chip, coordinating through Virginia.
Say it out loud and it sounds broken, because it is. It is also the default — the architecture developers reach for without thinking, because every tool they have ever touched assumed it.
The absurdity scales. Two coding agents in the same session pass context through a server farm. A humanoid robot and a mobile manipulator work the same warehouse aisle, a meter apart, and route their shared picture of the pallets through AWS. Two cars on the same highway exchange perception data through a cloud region in another province before they can agree on what they are both looking at. A drone swarm on a search-and-rescue grid syncs its observations over a satellite uplink to the cloud instead of over the mesh network humming between the drones themselves.
None of this is hypothetical. This is how Edge AI ships today. The cloud became the default for agent coordination not because anyone decided it was the right shape for the problem, but because nobody built the alternative and put it in the toolbox.
How the cloud became the wrong middleman for Edge AI
There was a time when cloud-first was exactly right. Devices were dumb terminals — a window onto someone else's computer. The client asked a question, the server knew the answer, and the single source of truth lived in a rack somewhere. For that kind of software, the model was not a compromise. It was the correct design.
AI inverted every assumption underneath it.
The device is not a terminal anymore. It runs the model. It holds the state. It takes actions in the world and generates observations the cloud will never see in time to matter. The thing the stack still calls a client is now the most capable computer in the loop, and the thing it calls the server is no longer where truth lives. When intelligence moved to the edge, the natural unit of communication moved with it. It stopped being client-to-server. It became agent-to-agent.
Cloud-routed sync is the holdover. It worked beautifully for software that no longer describes what people are building. Agents need to coordinate at speeds the cloud cannot reach, across networks the cloud is not part of, on devices that should never have to phone home just to talk to the device sitting next to them. The model did not fail — the software changed underneath it, and the model stayed put.
An agent working alone is the boring case. The agents worth building work together: the assistant acting for you across your phone and laptop, robots sharing a workspace, agents from different organizations grinding on the same problem. Multi-agent is not the frontier. It is the baseline. And every one of those agents needs to talk to the others without a referee in the middle.
Talking directly is a category of problem, not a feature
The easy version of this argument is that direct sync just means sending data over the local network instead of the cloud — skip the data center, bolt a sync endpoint onto whatever database you already have.
You cannot. Cloud sync and direct sync are not the same problem at different sizes. Serverless coordination has an entirely different shape, and that shape becomes obvious the moment you count what has to be handled.
Discovery comes first. In the cloud, the server is the phone book. Take it away and peers have to find each other another way — through mDNS, gossip protocols, and rendezvous points that no ordinary database ships with.
Time comes next. A cloud database orders writes by the server's clock. Peers share no clock, so agreeing on what happened first takes different machinery — logical timestamps and content addressable storage that makes an event's history part of the event itself.
Conflicts follow. With no server to pick a winner, the data has to resolve disagreements itself, deterministically, the same way on every device. That is the job of conflict-free data types, and it does not come from a database built on the assumption that a referee is always standing by.
Trust changes shape. Strip out the server and every piece of data has to arrive carrying proof of where it came from and that nothing was altered in transit. Verification becomes a property the data carries on its own.
Membership keeps shifting. A vehicle drops out in a tunnel and rejoins twenty minutes later. Nobody maintains a master roster, and the sync has to stay correct anyway.
None of these are features you add. Together they form a category of problem, and you do not reach it by adding an API to a database designed for one source of truth and many thin clients. A true local-first architecture has to be designed in from the data model up, or it is not really there.
The tax you are already paying
If your agent stack routes coordination through the cloud, you are paying for it — in the latency of a round trip you never needed, the cost of moving bytes to a data center to answer a local question, the privacy you spend every time raw observations leave the device, and the resilience you give up the instant a cloud link stands between two machines in the same room. Worst of all is the ceiling: a whole class of agent behavior simply does not work when every interaction has to clear a server first.
The agents people actually want break this model on contact. The assistant that follows you across your devices and truly remembers. Robots that coordinate at the speed physical space demands. Models that learn alongside their peers without raw data ever landing in one place. The teams that go edge-first will build the agents that work. The rest will keep treating cloud-routed sync as a law of nature.
The cloud is not the enemy. It is excellent at the problems shaped like it. Agent coordination is not one of them. It is peer-to-peer at its core, and it always was — the tooling just never admitted it.
At Source, we are building DefraDB, the distributed database built for the agentic edge.
