Two devices sit three meters apart. One has data the other needs. Suggest they exchange it directly, over the network they already share, and you will hear that building at the edge is hard, exotic, maybe a little crazy. Route the same bytes through a data center on another continent, and everyone nods. That is the sensible default.
It is worth asking what that sensible default actually does.
The machinery hiding under one API call
A single write to the cloud sets off a remarkable chain. The device resolves a domain, opens an encrypted session, and presents a token from an identity provider. The request passes an API gateway, a load balancer, and an autoscaling fleet before reaching a managed database that copies the write across data centers and runs a consensus round so machines in different buildings agree it happened. A change event hits a queue. A push service holding millions of connections sees the second device is listening and sends the payload back through the same gauntlet, retrying if anything stalls.
Total distance the data needed to travel: three meters.
None of this feels complex, because the developer no longer builds any of it. Every step became a managed service, a config line, an SDK call. Twenty years of tooling turned one of the most intricate pipelines ever assembled into a request a junior developer ships before lunch. The complexity did not disappear. It got absorbed.
The comparison was rigged
Now listen again to the claim that the edge is too hard. What is actually being compared? On one side, edge-first development with no tooling: hand-rolled sync, invented conflict resolution, devices that disagree about the world with no referee. On the other, the cloud after two decades of abstraction, every hard problem pre-solved and hidden behind an endpoint. Raw problems against buried problems. Of course the buried side looks simpler.
The verdict was never about which set of ideas is harder. It was about which side had its complexity absorbed first. Crazy is not adjacent machines talking to each other. Crazy is mistaking an abstraction layer for simplicity and declaring everything outside it too hard to attempt.
The absorption has already started
The same wave is now reaching the edge. On-device inference runtimes turned running a model, which recently meant a GPU cluster and a serving team, into a function call against hardware already in your hand. Edge AI stopped being a research posture and became a deployment target. Sync engines now ship offline-capable apps with no hand-written merge code, which quietly proves developers never hated local. They hated unabstracted local.
But these mostly absorb compute. The layer beneath them, the data itself, is where the oldest and hardest edge problems live: who wins concurrent writes, how state converges without a coordinator, how data proves its own integrity across hops nobody controls.
Agents will not wait for the round trip
These problems are about to stop being theoretical, because agents are following the models down. An agent in a delivery robot, a bedside monitor, or an orchard drone produces observations and memory at machine speed, and the peers that need that state are usually within radio range. A perception-to-action loop cannot put a cloud region in its critical path, and agent memory cannot live a continent away from the body doing the work. As agents move from cloud environments into physical ones, they inherit every unsolved edge data problem at a volume no human-operated system ever produced. For agents, the data layer is not one more thing to absorb. It is the precondition for showing up at all.
The primitives are ready
The building blocks have matured. Conflict free data types bake the merge into the data structure itself, so two devices write independently, exchange state when they reconnect, and converge with no locks and no referee. The "who wins" question is not answered; it is deleted. Content addressable storage names data by its own contents, so any copy is as trustworthy as the original and verification is built in rather than bolted on. Modern peer-to-peer transport handles the networking between devices with no public address, making the direct link the boring part again.
A database that lives where the work happens
Bind those primitives beneath one interface and the absorption is complete. The developer writes ordinary queries against a replica that lives on the device. The model is local-first: reads never wait on a network, writes commit locally and sync in the background through the merge logic, over the peer transport, with integrity guaranteed along the way. It looks like calling a local database because it is one. Everything hard about the edge gets pushed beneath the interface, exactly as the cloud did to everything hard about servers.
That is the destination: an edge-first developer experience where building for the physical world feels no different from building for the cloud, with the round trip demoted from mandatory to optional.
At Source, we are building DefraDB, a distributed database for the agentic edge. The mission is edge data management as simple and intuitive as the cloud made data feel.
