There is no connection string for a robot. No schema to query on a drone, no endpoint on anything that walks, rolls, or flies. A developer can build against a global payments network, a satellite imagery archive, and a frontier AI model without leaving their editor. The machine rolling past their desk offers them nothing to build against at all.
That gap is the thing to fix. The cloud's real invention was never compute on demand. It was addressability: every capability the cloud hosts sits behind an address, a schema, and a query any developer can reach. Physical hardware never got that. A device packed with compute, storage, sensors, and a model that can run inference locally is, to the working developer, functionally a rock.
The inheritance the cloud gave itself
When large language models arrived, they landed on twenty years of finished infrastructure: managed databases, auth, deployment pipelines, observability, billing. A team could wrap a model API and ship in a weekend because the model was the only new part. That speed was a property of the tooling underneath the models, and that tooling exists because every cloud capability is addressable by default.
Everyone now agrees compute leaves the data center next and moves into the physical world. Edge AI is where the next decade of value gets built, and agents are the workload expected to run there. The consensus stops at the destination. Nobody handed the physical world the same inheritance.
The 1.3 million
The numbers are stark. There are roughly 47 million developers in the world. About 2.8 percent identify as embedded developers, which works out to around 1.3 million people who can program a bare device. The other 45 million ship against a database, a schema, and a query. Edge hardware offers them none of the three.
That leaves any team that wants to build for the physical world with two options, and both are bad.
Option one: build without tools
The 1.3 million work with a serial cable and a ring buffer they wrote themselves. Deployment means flashing firmware and hoping the device in the field behaves like the one on the desk. No migrations, no staging, no observability beyond the logs someone remembered to keep. The modern loop of write, test, deploy, observe has no equivalent down here. This is not a knock on embedded engineering. It is a craft, and that is the problem. Crafts produce 1.3 million practitioners. Toolchains produce 45 million.
Option two: keep your tools a continent away
The other path keeps the cloud toolchain and tethers the device to it. It fails exactly where developers live: in the loop. Your framework deploys to a region in one command but has no idea what a device is. Tests mock the hardware because CI cannot hold one, so the first honest integration test happens in the field. Staging contains no physical machine, so it validates everything except the product. A schema migration reaches every server you own in one command, and no command reaches the fleet. Every tool still works. Every tool is also pointed the wrong way, and it quietly taxes every iteration until teams conclude edge AI is just slow to build. It is not. It is being built with instruments aimed at the wrong target.
The device becomes an address
Now picture edge AI built properly. A harvester in a field with no signal is not a firmware project. It is a database node: its telemetry is a collection you subscribe to, its configuration a document you write to, and when connectivity returns it syncs with its peers like any local-first system, through machinery you never had to write. A surgical arm becomes a schema you introspect and a query you run, with latency measured across the room instead of across an ocean. A drone's flight log is not a proprietary export. It is data, queryable where it was born.
None of this requires new physics. It requires the toolchain to leave the cloud, and that migration starts with the data layer, because tools orbit data. The test suite, the dashboard, and the deployment pipeline all live in the cloud for one reason: the database does. Move the database onto the device and the rest of the toolchain has somewhere to follow. That is what edge-first development means. Not cloud development with worse latency, but edge data management as a real discipline, tooling that treats the device as the primary environment and the region as the exception.
The market follows on its own. Edge hardware adoption is capped at the 2.8 percent who can program it bare. Make the device addressable and every developer who can build against it becomes a reason it gets bought and deployed. But the market is the echo. The event is the moment a device stops being a rock and starts being an address.
At Source, we are building DefraDB, a distributed database for the agentic edge.
