Something interesting happened today. I built a small tool that sets up the entire AirGradient GO development environment with a single click. The technical bits that used to take an evening of setting up now happen while you grab a coffee, leaving your computer ready to start changing how the device works.
Ater finishing the installer, I had a random thought: what if the AirGradient GO could also become an e-book reader? The GO is primarily a portable air quality monitor with an e-ink display, GPS, Wi-Fi, Bluetooth and environmental sensors. It was never designed to become an e-book reader.
But within about 30 minutes, using agentic coding, Codex modified the firmware and added a basic e-book reading functionality. Suddenly I was reading Alice in Wonderland on a portable air quality monitor.
Perhaps that's a bit of a crazy example, and probably not what most people would reach for. However, this is just an example and the same openness covers smaller, more practical changes too. Say you want the GO to log readings at different intervals than we offer by default, or you'd prefer the air quality warning to trigger at a stricter threshold than the one we ship with. With open firmware, those tweaks are yours to make.
And I think this is where things become much bigger than simply “AI writes code”. The surprising part is not that AI generated the code. The surprising part is that the hardware was open enough to allow it. Because increasingly, the bottleneck is no longer programming skill. The bottleneck becomes whether the device is actually open.
For most of computing history, changing how a device behaved meant learning a programming language and spending evenings deciphering documentation that assumed you already knew half the answers. Hardware tinkering stayed inside a small circle of engineers and dedicated hobbyists.
Agentic coding flattens that barrier in a way that is hard to overstate. You describe what you want in plain English, and the agent handles the parts that used to take weeks of study. Someone who's never written a line of C can ask for a new feature in the morning and have it running on their device by the afternoon. The skill that matters now is curiosity, and knowing what you'd like the device to do.
If the answer to the below questions is yes, entirely new possibilities emerge. If the answer is no, even the best AI coding agent in the world becomes largely useless. This creates a massive divergence between open and closed hardware ecosystems.
- Can the firmware be accessed?
- Can the hardware interfaces be understood?
- Can the build system be reproduced?
- Can the device be flashed and modified without restrictions?
For years, open-source firmware was often viewed as something mainly useful for engineers and hobbyists. Valuable, but niche. I think agentic coding changes this equation completely.
Because AI can now help understand unfamiliar codebases, write drivers, debug firmware, integrate sensors and explain hardware interactions. A device that once required months of embedded expertise to customize may soon require little more than curiosity and a good coding agent.
The AirGradient GO is a good example of this shift. Today it became an e-book reader. Tomorrow someone might turn it into:
- a hiking environmental logger
- a classroom science platform
- a GPS exposure mapper
- an offline weather terminal
And because the device exposes interfaces like I2C, entirely new hardware can be connected and integrated.
Over the last decade, we have watched perfectly functional hardware become electronic waste simply because cloud services disappeared, APIs were shut down or companies collapsed. We have seen smart home devices lose functionality overnight because the ecosystem around them was closed.
And no amount of AI can fix a locked bootloader, inaccessible firmware or proprietary cloud dependency.
This is why I believe openness becomes dramatically more important in the age of agentic coding and it becomes practical infrastructure for future innovation.
Open firmware means devices can potentially continue evolving long after the original company changes direction or disappears. Communities can maintain them, patch security issues, self-host services and extend functionality in ways the original creators never imagined.
Open-source hardware itself must also evolve
Publishing firmware repositories alone is no longer enough. In the age of agentic coding, hardware ecosystems need to become understandable not only for humans, but also for AI systems. That means reproducible build environments, structured hardware documentation, accessible APIs and clear interface definitions.
At AirGradient, and personally for myself, I want to commit to pushing this idea as far as we realistically can. We will continue publishing our firmware openly. We will publish the one-click development environment installer that made today’s experiment possible. We want to create detailed AI-readable hardware documentation, agentic development skills, MCP servers and open interfaces that make experimenting with our devices dramatically easier.
I want AirGradient devices to remain understandable, modifiable, repairable and extensible - not only by our own team, but by anyone curious enough to explore new ideas with them.
The future of hardware innovation will not come from companies trying to predict every possible use case behind closed walls. It will come from communities, developers, students, researchers and makers continuously evolving devices in ways the original creators never imagined.
In many ways, this feels similar to the early days of personal computing. The real revolution was not simply that computers became smaller or cheaper. It was that they became programmable by ordinary (tech) people. I believe open-source firmware combined with agentic coding may create a similar shift for the physical world. And I want AirGradient to help build that future as openly as possible.
