Pick an instance type. That single act carries a promise most developers never hear out loud: every machine your code touches will be the same machine. Same CPU family, same memory ceiling, same operating system, same runtime. When a cloud developer says their software runs everywhere, they mean a fleet of identical boxes they provisioned themselves. Uniformity was never a feature they chose. It is the water they swim in.
The edge does not honor that promise. There, everywhere means everywhere: a phone, a farm robot picking fruit in the rain, a browser tab inside someone else's software, and every strange machine in between, with different chips, memory budgets, operating systems, and power envelopes running from a wall socket down to a week-long battery. The same product spans all of it. An agent that only runs on one class of device is not an Edge AI product. It is a cloud demo sitting on hardware.
The uniformity the cloud quietly gave you
Almost everything in a developer's mental model assumes identical machines. Autoscaling works because the next node is a clone of the last. Containers promise that what works on your laptop works in production, because production is the same abstract machine your container already targets. Ask a backend engineer what CPU their service runs on and you will often get a shrug. Not carelessness: the answer never mattered, because the metal was always the same metal. That assumption sits so deep in the stack that most developers do not know they are making it.
The edge is not a platform. It is every platform.
At the top of the range, hardware looks almost like the cloud: a humanoid robot with a GPU and the power budget to feed it, a bedside diagnostic unit with server-grade compute on a cart. At the bottom, a smartwatch has a fraction of a phone's memory, and a subsea sensor runs a microcontroller that makes the watch look lavish. Orders of magnitude separate the top of the edge from the bottom, and both ends belong to the same product.
Not by running the same workload. Capability decides where the work runs: the sensor streams what it sees to a device that can think about it, and the answer flows back down. The middle is where it gets strange. A delivery drone's every gram of compute is a gram of battery it cannot carry, so inference competes with flight time. A vehicle fleet ships different chips across model years, so one update lands on six hardware generations at once. These are not different markets. They are often the same deployment: a personal agent expected on your phone, laptop, watch, and browser, with one memory across all four.
What heterogeneity does to an agent
The model gets attention first, and for good reason. A model that hums on a phone's Neural Engine has no room on a watch, so it gets quantized, distilled, or swapped for a smaller architecture. The pipeline underneath adapts too: GPU inference on the robot, CPU inference on the phone, a hosted fallback when the device cannot carry the model at all.
Underneath both sits the part almost nobody talks about. An agent's state, memory, sync, and access control live in a data layer, and that layer has to run on every device the agent inhabits, or the agent simply does not exist there. A data layer that assumes a real filesystem does not run in a browser tab. One that assumes 8 GB of RAM does not run on a watch. One that assumes a constant connection does not run on a drone that spends half its mission out of range. The model gets the keynote. The data layer decides whether the agent actually works.
What running on everything requires
Portability stops being a convenience here. Write once, run on everything is the entry requirement, not an aspiration. Three things make it real.
Size. The data layer must be small enough for the smallest target and capable enough for the largest, with portable execution that does not presume a particular operating system, filesystem, or chip.
Identical guarantees. An agent is coherent behavior, and behavior lives in state. If the watch enforces different access rules than the phone, or the browser remembers different things than the laptop, the agent fractures into several agents wearing one name. The same state, sync, and access control everywhere is what keeps it one agent.
Graceful scaling. Use the GPU when it is there. Work without it when it is not. Degrade capability, never correctness.
The conclusion is blunt. Edge data management cannot be a per-device affair. Ship a different data layer for each class of hardware and you do not have a coherent agent. The layer has to be one thing that runs everywhere.
The bill comes due
The cloud let a generation forget that hardware exists. The edge is that bill coming due. Your users are not on one device, and they expect the same agent, with one memory, wherever they are standing. An agent that runs on everything is not a nice-to-have. It is the difference between a product and a prototype.
At Source, we are building DefraDB, a distributed database for the agentic edge.
