The M-VAVE FM-1 is a pocket FM synthesizer that sells for about $70, and almost nobody who owns one still runs the firmware it shipped with. Owners started writing their own in September. By October there were too many to cover in one article: a virtual analog synth, a multitrack groovebox, a dark ambient sampler, and a port of Doom. Yes, the video game. Going by what the developers post on the forums, nearly all of them were written with AI coding tools.

Video: Custom Firmware Tierlist by AudioPilz, ranking FM-1 firmwares.

Then M-Vave did something uncommon for a hardware company. In October it published its own firmware as open source under GPLv3, along with a development kit and a browser emulator for testing custom builds before you flash them.

I think this is where most consumer gadgets that run their own firmware are headed: synths, TVs, routers, printers. When software is cheap to write, the firmware a device ships with is just the first version. Devices that let owners replace it will sell better than devices that don’t. Most buyers won’t care about that. Their AI agents will, and more buying decisions are going to run through agents.

Owners already replace the software

When a device doesn’t do what its owner wants, most people put up with it. Some replace the software, and in a few categories that’s already normal.

Cheap retro handhelds from Anbernic and others ship with firmware that buyers usually replace within days, and muOS and Knulli are the standard recommendations. Pebble came back as a fully open project. Core Devices published the OS, the phone apps, and the hardware schematics, and the phone app can install from app stores anyone can run. I replaced the home screen on our Google TV, which runs Android, with a custom launcher built for our family, with no ads and no tracking. Ubiquiti owners hook their network controllers up to AI agents through community-built servers and have the agent audit firewall rules and tune the network. That isn’t new firmware, but the agent is already running the device.

Writing firmware got cheap

Writing firmware used to mean reverse engineering the chip, learning a vendor’s toolchain, and weeks of trial and error. The FM-1 runs on a JieLi chip with little public documentation, and owners still had working firmware within weeks.

AI made each part of that cheaper. It can read undocumented code, write new code for an unfamiliar chip, and build the editors, installers, and emulators around it. A motivated owner can now get through all of it in a weekend. Once that’s true, any device with writable flash is a platform, whether the maker planned for it or not.

Agents will do the installing

Most people don’t think about improving their devices. They use what they get. So right now custom firmware reaches a small group: a few people write it, and a somewhat larger group finds it and installs it.

I don’t expect that to last. As agents take on more everyday work, the owner stops being the one who installs things. You ask your agent to fix something that bugs you about a device. It tries a setting first. If that doesn’t work, it looks for firmware someone else wrote, forks the closest match, or writes its own. You see that the problem went away, and you may never know the device is running custom code.

How fast this happens depends more on the hardware than on AI. The device has to accept new firmware, and signed firmware and locked bootloaders stop that. The agent needs a way in, like USB or a browser tool such as M-Vave’s Workbench. And a bad install has to be recoverable, since an agent can’t open the case and fix a bricked board. M-Vave added a tool that puts the stock firmware back in about ten seconds.

Your agent will pick the hackable one

This changes how people buy hardware. Ask your agent which TV, router, or synth to get, and it will lean toward the one it can change, because that’s the one it can fix later. The buyer never has to think about openness for it to matter.

That pressure is what gets makers to open up, and it works fastest in categories where people compare options every time they buy: synths, TVs, printers, routers. Music gear is already moving. M-Vave opened its firmware within weeks of owners starting, and within two weeks after that Behringer published firmware source for its upcoming KICK sampler and IGNITE sequencer. Its parent company said it will open selected designs so owners can use AI to write their own firmware, and Akai and Erica Synths announced the same for some of their gear.

It will be slowest where switching is hard. People don’t shop for a new phone platform every year, because their messages, photos, and family accounts keep them on the iPhone. But Apple still sells to new buyers and to people replacing old phones, and more of those decisions will go through an agent. I expect Apple and other makers whose customers rarely leave to answer with deep, approved agent access to the OS, and to keep the firmware closed.

Where closed companies push back

An open device is only useful if it works with everything else the owner has: their phone, their accounts, their cloud services. Pebble needed a working iPhone app before anyone would buy the watch. Home Assistant is useful because it connects to devices from companies that never planned for it. That’s where closed companies keep control, since they decide who can connect. Chamberlain cut Home Assistant off from its MyQ garage door openers in 2023.

The reason closed companies usually give is security. Bambu Lab added server authorization to its printers’ firmware as a security update. Owners read it as lock-in, and some well-known customers said they would stop buying. Google now requires app developers to verify their identity before their apps can be installed on certified Android devices, a rule in effect in four countries since September 30 and planned worldwide for 2027. Google’s stated reason is malware, and cheap code makes that argument stronger: harmful firmware is as easy to write as useful firmware.

Some of this is real security and some of it is lock-in, and you can usually tell which by asking who controls the signing keys. A device can refuse unsigned firmware and still let its owner add their own key. Pixel phones already work this way. If a maker blocks code the owner chose and signed, that block is protecting the maker’s business.

Open firmware might even make things safer. When millions of devices share the same weakness, one attack works on all of them; the Mirai botnet did exactly this in 2016. A mix of different firmwares makes that harder, though AI that finds bugs cheaply also makes it cheaper to go after many variants at once. The bigger risk is malicious firmware dressed up as something useful. Verified installers, owner-held keys, recovery modes, and agents that check firmware before they install it all help with that, and none of them require locking the device. I’d expect agents to favor devices that have them.

What makers learn, and who the agent works for

Custom firmware also changes what a maker knows about its own product. Right now a modified device is a support cost. Soon the owner’s agent will contact the maker’s support agent, explain what it changed and what broke, and get advice drawn from every other owner who tried something similar. A maker with open devices finds out what people want much faster than it would from surveys. A closed maker doesn’t get that information at all, because nobody is building on its devices.

This only works if the agent works for the owner. An agent that recommends the device it can fix pushes makers toward openness. An agent built by a company with its own devices to sell may not. Who your agent works for will decide whether this helps consumers or just moves the lock-in somewhere harder to see.

If I made hardware, I’d plan for the firmware I ship to be replaced, and I’d make replacing it easy and safe to undo. Those are the devices agents will recommend.