The Standard That Could Make MCP Look Small
Anthropic just previewed a shared language for AI agents to run lab and factory equipment. The pilot results are stronger than anything MCP shipped with at launch. Here is the honest case for why it could matter more, and why it is not there yet.
Walk into most research labs or factory floors and you will find a room full of expensive equipment that refuses to talk to itself. A liquid handler runs on one vendor's software. A robotic arm runs on another's. A plate reader speaks a third language entirely. Getting them to cooperate on a single experiment has always been a specialist's job: weeks of bespoke integration work, one brittle bridge at a time, before a single autonomous run is possible.
On August 27, Anthropic previewed something aimed directly at that problem. They call it the Model Hardware Standard, MHS for short, and it is worth understanding now, before the headlines settle into a single sentence.
The problem nobody outside a lab ever sees
Software integration is a solved problem in most of the industry. Two applications that both speak REST or both understand MCP can find each other in an afternoon. Physical equipment never got that courtesy. A microscope, a centrifuge, and a robotic arm are built by different manufacturers on different decades of tooling, some exposing a Python SDK, some Java, some nothing more than a serial port and a PDF manual.
The result is a tax nobody budgets for honestly. Labs and manufacturers routinely spend weeks or months just getting instruments to cooperate before the actual science or production can start, and every new device added to the workflow reopens the same integration project from scratch. It is the same failure mode I have spent a career fixing in software platforms, one layer further down the stack, where the cost of a missing standard is measured in idle lab benches instead of idle engineers.
How MHS actually works
Strip away the demo videos and MHS is a fairly simple idea, built in three layers.
1. Driver layer
Every device exposes a small set of primitives: read commands like get temperature, write commands like set temperature, plus a natural-language description of what the device is and what it can safely do. This is what makes a device discoverable to an agent that has never seen it before.
2. Access layer
An agent reaches that driver through one of three doors: the Model Context Protocol, a command line interface, or a direct code and API path. MHS does not replace MCP here, it sits on top of it as one of several ways in, which is what makes the standard model-agnostic rather than Claude-specific.
3. Execution layer
Once a workflow is proven, it does not need to keep asking a model to reason at every step. The agent can compile what it learned into a deterministic script that runs at machine speed, and fall back to full reasoning only when something unexpected happens.
That third layer is the detail most coverage skipped past, and it is the one that matters most to anyone who has run a platform. A system that has to re-reason from scratch every time is a demo. A system that graduates from reasoning to a fast, inspectable, repeatable program is an operating discipline.
The pilots, and why they are the real news
Anthropic ran the preview with six organizations, and the results read less like a product launch and more like a set of independent case studies that happen to agree with each other.
Genentech pointed Claude at a protein assay that required coordinating a liquid handler, a robotic arm, and a plate reader. Left to work out the fluid dynamics itself, the agent tuned flow rates for water and for a much more viscous protein solution to a tight error margin, and recovered on its own from tip pickup failures and fluid detection errors along the way. It also hit a real limit worth noting honestly: it did not understand bubble formation as a physics problem rather than a software bug, and needed a human to close that gap. Carnegie Mellon ran a dose-response experiment across three incompatible instrument interfaces, finished the integration in about eight hours against a typical multi-week timeline, and watched the agent notice a bad first run, correct its own concentration range on the second attempt, and land a clean result.
The University of Washington's Baker and Pinglay labs connected six separate instruments in under a week, something that had taken months before, and ran repeated robotic handoffs between a liquid handler and a robotic arm without a single collision. HHMI's Janelia campus unified seven different vendor programs controlling one microscopy rig, cutting the time to add a new camera from a multi-day project to minutes. QuEra Computing, working on neutral-atom quantum hardware, is the sharpest number in the whole preview: a hand-written recovery script for a laser frequency lock succeeded 58 percent of the time and took roughly 150 seconds per attempt; the agent-built version succeeded 99.3 percent of the time in under 15 seconds, and in a 19-hour stability test it held the lock continuously while an expert-tuned baseline dropped it roughly every 40 minutes.
Tetsuwan Scientific is the least glamorous pilot and maybe the most convincing one: a citizen-science water-quality project running qPCR workflows at real volume, 9,143 individual dispenses across 300 transfer types, with the resulting precision model improving by roughly 12 percent over manufacturer specifications. Nobody was performing for a keynote. It was just work, running better.
MCP taught AI agents to read our software. MHS is teaching them to touch our machines.
Is this really bigger than MCP?
Here is the honest version of that claim, not the headline version.
The case for yes is about surface area. MCP standardized how an agent reaches software and data that already existed in digital form: APIs, files, databases, tools someone had already built. That is a large market and MCP earned its place in it fast. MHS is aimed at something larger still: the physical economy that has not been digitized at all, the labs, factories, and equipment fleets where the bottleneck was never the AI, it was the total absence of a common language for machines to be operated by anything other than the specialist who installed them. If AI ever runs meaningful parts of manufacturing and scientific research the way it now runs meaningful parts of software work, the standard that made that possible will have mattered more than any standard that came before it, MCP included.
The case for not yet is about maturity, and it is not a small gap. MCP has a public specification, open governance, SDKs in every major language, and thousands of production integrations built by people who do not work at Anthropic. MHS has six pilot partners, a set of genuinely strong results, and no public specification, repository, or open license yet. Anthropic has said the plan is to open-source it once the preview generates enough safety findings to publish real guidance, not on a fixed date. Betting on MHS today is a bet on a trajectory, not a bet on something already built the way MCP already is.
What this means if you lead a platform
I wrote last week about the discipline that transfers across every platform I have built, regardless of domain: adoption is the product, trust is won in the migration, and generality has to earn its way in rather than being designed up front. MHS is that same discipline one layer further down, applied to physical devices instead of software services. The driver layer is an adoption bet: it only works where a device already has a programmable interface, which means the first fight is the same one every platform fights, getting reluctant vendors to expose an API at all. The three-way access layer is a trust bet: building on top of MCP instead of replacing it is exactly the kind of humility that earns a new standard the benefit of the doubt from people who already trust the old one.
If you run a team anywhere near hardware, robotics, or lab automation, this is worth tracking closely over the next two quarters, not because MHS is finished, but because the pattern that made MCP the default in eighteen months is visibly repeating, this time with harder proof points on day one.
MCP made the case that AI needed a common language for software. MHS is making the case that it needs one for everything else. The pilots are real. The maturity is not there yet. Both of those things are true at once, and the honest read is more useful than either the hype or the dismissal.
Haseeb Afsar