Software already got personal. People build their own applications now, for their work and their lives: a dashboard for one team, an app that tracks a personal collection, an agent wired to your own notes, the one tool you kept wishing existed. With an agent sitting in the editor, this has become ordinary. The gap between "I wish this existed" and "I built it" keeps shrinking.

The devices around us are heading the same way, and someone is going to write the software for them.

Small devices are multiplying anyway

This part is already happening, and we aren't the ones making it happen. Vendors and the hardware industry are flooding the world with small personal devices: watches and bands, AI glasses, e-paper dashboards, room controllers, health displays, desk companions. Wearables alone ship more than 600 million units a year, and that number keeps growing. A capable ESP32 board costs about seven dollars, and the silicon keeps getting cheaper. The hardware is arriving on its own, in volume, cheaply.

So the interesting question isn't whether personal hardware is coming. It's who gets to write the software that runs on it. Right now the manufacturer decides that once, ships it, and moves on. You wear a watch against your skin all day and you don't get to say what it does. That's an odd situation in 2026, when a junior developer can reshape a CRM in an afternoon but the gadget on the wrist is sealed shut.

Agents want to run where the sensors are

There's a second reason the software is about to matter more. The interesting agents want to see and hear and sense the world: camera, microphone, motion, location, presence, a pulse. None of that lives in a browser tab. It lives on devices. An agent that only knows what you typed is worse than one that knows you're in the workshop with your hands full. Physical context is the next thing agents are reaching for, and reaching for it means more software that has to run on personal hardware, close to the sensors, not in a data center.

That's a lot of software waiting to be written, for a lot of small devices, each doing one thing for one person. Not one universal gadget that does everything. Many small ones, each with its own interface, its own purpose, its own handful of people who care.

The door is opening from several directions

The platforms are already inviting this software in. Pebble's watch software went fully open source and the old community showed up again — some people just want a small hackable thing they can bend to their own use, and now they can build apps for it again. Meta and Mentra both let you build for their glasses with the web. Google's XR Blocks brings Android XR within reach through WebXR. The pattern is clear: the people who own the devices are reaching for the way most software already gets built.

And that way is the web, which is about as big and as proven a base as you can build on. It's where an enormous number of people already work, the environment they trust and reach for by default, with a community and a body of knowledge that dwarfs anything else. The barrier to trying something unfamiliar is dropping, too: a coding agent will walk you through a setup you've never seen, write the boilerplate nobody enjoys, and tell you why a build won't link. The distance between what you already know and building for a new device has never been shorter.

The embedded toolchain still locks it out

Here's the catch. To put a decent interface on a seven-dollar board today, you still need C++, a board SDK, a hand-written display driver, careful accounting for every byte of RAM, a build system, a flasher, and a serial cable for debugging. None of that looks anything like building for the web, so the way most people build interfaces stops at the edge of the device.

Raising the software boundary

The fix isn't turning everyone into an embedded engineer. It's moving the software boundary up the stack, so the parts that should feel like the web do, while the result still runs as native code on the device.

This is why we're building GEA. One codebase, written the way you already build for the web, compiled ahead of time to native code. The same source targets a microcontroller, embedded Linux, a Mac, a phone. You should be able to build the interface and the software that runs on these devices without first getting a second degree in firmware. The compiler handles the translation. The devices already exist; what we open up is the software on them.

What stays hard

We are not promising that hardware gets easy. Manufacturing at volume is still hard. Certification is still slow and expensive. Radios, antennas and power budgets still punish careless choices. Supply chains still bite. Designing a device is real engineering and it stays that way, and that is not what we're claiming. Our claim is narrower and it lives at the software layer: as personal devices multiply, far more people should be able to write what runs on them.

That's where most personal software will live. One device, one purpose, a small number of people who care, and an interface someone could finally build without asking permission from the embedded toolchain.

The age of personalized hardware is coming. The devices will arrive on their own. What decides whether they're worth owning is the software, and the question that has always mattered most: who gets to write it.