Hardware is becoming an API

You have never touched the server running this page.

You have never touched the GPU that trained the model you asked to summarize it. You have probably never touched the phone your app got tested on last CI run, or the browser your scraper drove this morning. Four physical, scarce, expensive machines. Four times, someone put an API in front of the machine and the industry stopped touching it.

This is a pattern with dates attached, and it has repeated often enough that you can predict the next hardware API before it ships.

The pattern, not the vibe

Every time it happens, it happens for the same three mechanical reasons, in order:

1. Scarcity. The resource is physically limited — one server rack, one GPU cluster, one drawer of test phones, one Chrome process. Not everyone who wants it can have one sitting on their desk.
2. Parallelism. Once the resource sits behind a network boundary instead of a desk, it can be pooled and multiplexed. One rack becomes a thousand tenants. One GPU cluster becomes a rented hour. One phone becomes a queue any CI job can join.
3. Automation pressure. The moment there's an API instead of a login prompt or a physical cable, software starts calling it directly — scripts, CI pipelines, and now agents. Software doesn't ask for one unit at a time. It asks for as many as the API will give it.

Scarcity is why the resource needed pooling. Parallelism is what pooling behind an API buys you. Automation pressure is what happens once machines, not humans, are calling that API. Each wave shipped in that order.

Four times it already happened

Resource	Before	The API moment	What changed after
Servers	Rack your own box, wait weeks for a data-center slot and a sysadmin	Amazon EC2 public beta, August 25, 20061 — pay-per-hour virtual servers, launched by API call	Startups stopped owning data centers; "provisioning a server" became a function call
GPUs	Buy or lease a physical GPU cluster, share it by spreadsheet and grudge	AWS Cluster GPU Instance (cg1.4xlarge), announced November 20102 — the same pay-as-you-go API extended to GPGPU	Nobody buys a GPU cluster to train a model; you rent GPU-hours, and the entire ML training boom rides on that rental market
Phones	QA's drawer of real handsets, one USB cable, one tester, one device at a time	AWS Device Farm, launched July 9, 20153; Firebase Test Lab for Android, June 20164 — schedule a test run against real devices over an API	Mobile CI runs hundreds of real-device tests per pull request; nobody keeps a device drawer to ship an app anymore
Browsers	Self-hosted headless Chrome, hand-managed sessions, crashes at 2 a.m.	Browserbase, founded early 2024 by Paul Klein IV, opened its cloud browser API the same year5	AI web agents rent browser sessions by the API call instead of running their own Chrome farm

Same shape, four times, roughly a decade apart. Each row starts with a human physically operating scarce hardware and ends with software calling an endpoint.

Chips are the dashed line. There's no chip row in that table with a filled-in "what changed after" column, because that column hasn't been written yet. That's the bet.

The same shape shows up elsewhere: search, memory, and browsers all got their own rental market, mapped end to end across the whole agent infrastructure stack. Compute got there through E2B, which gives an agent a computer but not a microcontroller. Chips are the one row still empty.

Why there's no hardware API for chips yet

Chips have all three preconditions already.

Scarcity: a dev kit is one board, and during the 2021 chip shortage, semiconductor lead times stretched past 26 weeks⁶ — getting a board took months, not the usual next-day shipping. Parallelism: a physical board can run exactly one test at a time, full stop — there's no multiplexing a UART. Nobody has pooled it. Automation pressure: this is the one that just changed, and it changed fast.

Agents make it 100x worse

For twenty years, "automation pressure" meant a CI script hitting an API a few times an hour. That's what EC2, GPU clouds, and device farms were built for, and it was plenty to justify each one.

An agent generating firmware doesn't hit an API a few times an hour. It proposes a fix, gets it wrong, proposes another, and does that in a loop with no coffee break and no meetings. Fifty candidate changes before lunch is a normal afternoon for a coding agent working an embedded repo. Every one of those fifty needs to build, run, and ideally get proven against something that behaves like the real chip — a green build already isn't proof of that.

A CI script can wait its turn for a shared bench and still ship on schedule. An agent that generates work faster than any human queue can absorb turns "wait your turn" into the bottleneck for the entire loop. The automation-pressure leg of the pattern didn't just show up for hardware — it showed up already running at a pace none of the four earlier waves had to handle on day one.

And there's a harder floor under all of it: an agent cannot pick up a JTAG probe.

It can write code. It cannot walk to a bench, find the right cable, plug it into the right header, and power-cycle a board that's stuck in a bad state. Every one of the first four waves eventually got automated by scripts that still, in principle, a human could have run by hand, just slower. This one is different: the physical step has no manual fallback for the thing doing most of the work now. If the chip isn't behind an API, the agent's loop simply stops at the point where a human has to intervene with their hands — every single time.

What "the API moment" actually requires

The API moment was never "make the resource faster." EC2 servers weren't faster than a rack you owned. Cluster GPU instances weren't faster than a GPU on your desk. A phone in a Google data center isn't faster than the one in your pocket. Every API moment was the same move: stop requiring a human to be physically present to operate the thing, so software can operate it at whatever rate it wants.

An API doesn't care if the caller is a cron job, a CI pipeline, or an agent running fifty iterations before lunch — and hardware still does.

We're building Chiplab to be that layer for chips: firmware built, run, and observed against virtual hardware for AI agents, delivered over an API, so an agent's fiftieth iteration this hour doesn't have to wait for the one physical board on the desk.⁷ Call it hardware as an API and you've described exactly what Chiplab does. I'm not going to pretend that's the whole story — some bugs are electrical, and no API replaces a scope on real silicon. That's a real boundary, and it's a separate post. But everything short of that boundary is exactly the part of the loop the last four waves already proved doesn't need a human standing next to the machine.

Servers went first. Then GPUs. Then phones. Then browsers. Each time, someone got tired of a human being the bottleneck between software and a scarce machine, and put an endpoint in the way instead.

Hardware is becoming an API.

Sources

Footnotes

1. Amazon Elastic Compute Cloud, "History" — Wikipedia. Public beta announced August 25, 2006. https://en.wikipedia.org/wiki/Amazon_Elastic_Compute_Cloud ↩

2. Jeff Barr, "New EC2 Instance Type – The Cluster GPU Instance," AWS News Blog, November 2010. https://aws.amazon.com/blogs/aws/new-ec2-instance-type-the-cluster-gpu-instance ↩

3. Frederic Lardinois, "Amazon Launches AWS Device Farm, Lets Developers Test Android And Fire OS Apps On Real Devices," TechCrunch, July 9, 2015. https://techcrunch.com/2015/07/09/amazon-launches-aws-device-farm-lets-developers-test-android-and-fire-os-apps-on-real-devices ↩

4. Doug Stevenson, "Introducing Firebase Test Lab for Android," Firebase Blog, June 2016. https://firebase.blog/posts/2016/06/introducing-firebase-test-lab-for ↩

5. Jimmy Song, "The New Era of Cloud Agent Infrastructure: In-Depth Analysis of E2B and Browserbase," September 3, 2025. https://jimmysong.io/blog/e2b-browserbase-report ↩

6. KPMG, "Surviving the Silicon Storm," 2021. https://assets.kpmg.com/content/dam/kpmg/br/pdf/2021/06/automotive-semiconductor-shortage.pdf ↩

7. Chiplab. https://veecle.ai/chiplab ↩