The Socket Wars: MCP Ate HomeKit, and the Bill Lands on Crypto

Three Numbers, Three Lies

Here is the table that should have stopped every smart home analyst cold, and almost nobody looked at it twice.

Apple HomeKit: roughly 1,000 compatible devices. Amazon Alexa: 140,000. Google Home: 85,000. Samsung SmartThings: about 2,500.

Read that again. Two of those numbers are separated by two orders of magnitude. One of them sits at a scale that makes no sense next to the other three. That is not an ecosystem gap. That is four research teams measuring four different things and then drawing a bar chart.

I have been here before. In crypto, the same lie shows up every quarter under a different label: total value locked, active wallets, "integrations." One project counts unique depositors, another counts vault contracts, a third counts a single aggregator that touches forty protocols as forty integrations. The dashboard renders identically. The insight is worthless.

So before I get to the part that actually matters, front-load the correction: those device counts cannot be compared, and any argument built on the raw gap is a marketing argument wearing a spreadsheet. SmartThings at 2,500 is almost certainly counting certified brands, firmware lines, or a single product category, not addressable endpoints. HomeKit's number is probably a certification list. Alexa's 140,000 is likely device models by SKU.

Now the part that does matter, because it survived the audit. Somewhere in the last eighteen months, Amazon quietly stopped shipping speakers and started shipping a socket. It opened device capabilities from Bosch, Whirlpool, and iRobot through MCP — the Model Context Protocol — so that an agent could call a dishwasher the way a program calls a function.

That is the story. Not the device counts. Not the keynote demos. A tool-calling protocol is being installed as the interface layer of the home, and whoever owns the socket owns the fee schedule.

Fee schedules are where crypto enters, whether the incumbents want it or not.

A necessary flag before we proceed: much of the sourced timeline here sits in 2026 — announcements, reviews, shipping windows. Treat the specifics as trend forecasting, not verified fact. I would rather hand you a forecast labeled as a forecast than a fact with a broken provenance chain. Curiosity is the only honest position, and honesty about uncertainty is the only way to stay honest at all.

The Moat Moved One Layer Up

For a decade, Apple's smart home strategy was coherent. Own the connection layer. HomeKit plus Thread plus the secure enclave made the home a trust boundary, and the trust boundary made the iPhone the keys. Nobody beat Apple at connection-layer discipline. Matter then commoditized exactly that.

When Matter shipped, it turned device pairing into a utility. Every major platform could onboard the same bulb, the same lock, the same thermostat. Apple's ten-year investment in pairing rigor became table stakes that everyone got for free. That is what commoditization looks like: your moat becomes a specification, and specifications get signed by committees.

The moat did not disappear. It moved up a layer. The competitive question stopped being "can your phone talk to this device" and became "can your agent plan across this device and five others without human intervention."

Connection layer out. Orchestration layer in.

This is where Apple's problem becomes architectural rather than cosmetic. Siri was built as a pipeline: automatic speech recognition, then natural language understanding, then intent and slot filling, then a handler that executes one action. That architecture is a chain of narrow models passing structured handoffs. It works beautifully for "turn on the lights" and degrades immediately for "figure out why the kitchen is warm, check whether the oven was left on, and if the windows are closed, cool the room instead of opening them."

The second request requires state, multi-step planning, tool selection, verification, and a retry path. That is not a better NLU problem. That is a different program.

Apple Intelligence is a hybrid design — small on-device models plus private cloud compute for heavier work. Reasonable engineering. But there is a real difference between replacing modules inside a pipeline and rebuilding the runtime around an agent loop. Module replacement preserves the old skeleton and inherits its ceiling.

The published claim that roughly 95% of processing happens locally is the kind of number that means everything and nothing at once. It is almost certainly true for a specific workload class: photo semantic indexing, keyboard prediction, on-device summarization. It tells you very little about the cloud dependency of a multi-turn agentic conversation, which is the workload that now defines product quality. Selective disclosure is not lying. It is framing, and framing is where analysts get caught.

The three market categories the market settled into are worth naming plainly, because Apple fits none of them:

Open and DIY — Hubitat, Home Assistant, the tinkerer stack. No cloud dependency, no polish, no mass market.

Cloud-native — Alexa and Google Home. Maximum capability, maximum data gravity, subscription economics attached.

Local-first hardware — the emerging category of purpose-built devices that keep inference on-premises and sell privacy as the product.

Apple sells a phone that happens to control lights. It has the privacy posture of the local-first camp with the capability position of neither. That is a vacuum, not a niche.

What a Socket Actually Looks Like

Strip the branding and MCP is legible in about ten seconds. A device publishes a manifest of callable tools. An agent reads the manifest, decides which tool matches the goal, sends structured arguments, and receives structured output. The device is no longer a UI target. It is an API endpoint.

The Code Check

Here is a trimmed tool manifest for a smart lock, the kind of thing an agent would read at discovery time. I have written it in the shape you would actually see, then annotated the fields that are missing.

{
  "server": "lock.bosch.home",
  "protocolVersion": "2025-xx-xx",
  "capabilities": {
    "tools": [
      {
        "name": "lock.set_state",
        "description": "Set deadbolt state for an entry point.",
        "inputSchema": {
          "type": "object",
          "properties": {
            "device_id": { "type": "string" },
            "state": { "enum": ["locked", "unlocked"] },
            "duration_s": { "type": "integer", "minimum": 0, "maximum": 900 }
          },
          "required": ["device_id", "state"]
        }
      }
    ]
  }
}

Now list what is not in that schema. There is no price. No payer. No receipt. No nonce for replay protection. No attestation field proving which code actually executed. No jurisdiction tag for where the physical actuation is permitted to occur. No liability clause for what happens when the lock opens because the model hallucinated a device_id.

An agent can open a physical door through this interface and the protocol has no opinion about who paid for the inference that decided to do it, who can prove the decision happened, or who is accountable if it was wrong.

That absence is the alpha. Decoding the invisible edge in the block is usually about reading the fields that exist. Sometimes it is about inventorying the fields that do not.

The Latency Budget Nobody Publishes

Run the arithmetic on an agentic home interaction and the architecture debate resolves itself.

Speaker-to-wake-word: 100 to 300 milliseconds. Wake-word to ASR finalization: 200 to 500 milliseconds round trip if the ASR is cloud-side. Then the planner, which for a multi-step task means at least two and often four to six inference round trips, because the agent has to read tool results before deciding the next call. At 300 to 800 milliseconds per cloud round trip, a five-step plan lands between 1.5 and 4 seconds before the actuator moves.

A wall switch is instant. That is the comparison users make, even if they never say it out loud.

The industry's answer is a split: keep perception and fast-path intents on-device, push planning to the cloud, cache aggressively, and pre-execute likely next steps. Every one of those mitigations is a bet that prediction beats physics. Sometimes it does. When it does not, the failure mode is a house that hesitates.

This is where the edge inference story stops being a hardware-enthusiast topic and becomes an infrastructure topic. Multi-modal understanding on a refrigerator door, vision models tracking food spoilage on a camera with a mid-tier SoC, always-on audio gating — all of it requires NPU and ISP headroom that appliance bill-of-materials teams have spent twenty years trying to remove. Someone is going to pay for that silicon. Right now, nobody has published who.

The Meter Problem

The pricing that surfaced is concrete enough to reason about. Amazon's Alexa tier at $19.99 per month for non-members, with Prime bundling quietly flattening the curve. Google's Gemini for Home at $99.99 of hardware plus a two-tier subscription structure.

Look at the shape rather than the numbers. Hardware priced near or below cost. Recurring revenue attached to the device. That is not a product business. That is a customer acquisition cost with a lifetime value hypothesis stapled to it, and the hypothesis is unverified because nobody has published conversion or ARPU.

Here is where my own work becomes relevant, and I will be specific about it because vague credentials are a tell. Last year I built a small autonomous trading agent that paid for its own compute in USDC. Nothing exotic: a sentiment pipeline, a decision layer, a wallet with a policy cap, and a metered billing loop where every inference call settled in stablecoin before the response was released. Thirty days of parallel operation against my manual workflow. About a 15% improvement in execution speed, mostly from removing human confirmation latency on routine decisions.

The interesting finding was not the speed. It was that per-call metering changed the agent's behavior in ways subscription pricing never could. When every inference has a visible price, the planner learns to batch, to cache, to skip. When inference is bundled into a flat monthly fee, the rational strategy is to call constantly and let precision degrade. Flat subscriptions subsidize sloppy planning. Meters discipline it.

Now apply that to a home. An agent that pays $19.99 a month regardless of usage has no reason to ever be efficient. An agent that pays per tool call has a reason to plan well — and, critically, a way for the device manufacturer to get paid for the capability it exposed.

Which brings us to the part that should worry every appliance brand on earth.

Ordering Rights Move Into the Living Room

The agent loop has a structural twin that anyone who has spent time in block building will recognize instantly. The planner is a block builder. The tool calls are the transactions. The platform hosting the model is the relay. And the value capture sits exactly where it always sits: with whoever decides what gets included and in what order.

When Bosch exposes a dishwasher capability through a third-party agent ecosystem, the household's intent no longer routes through Bosch's app. It routes through the platform's planner. Bosch becomes a searcher with no orderflow. It supplies the execution, absorbs the hardware cost, and watches the relationship, the telemetry, and the upsell surface get intermediated by a company that owns none of the physical product.

Mining insight from the miner's extractable value was never only about MEV. The pattern is general: whoever sequences execution captures the surplus, and the entity performing the work is paid last and worst. A dishwasher that can be called as a tool is a dishwasher that has been asked to become a validator without a block reward.

In crypto we watched this movie with wallets. Wallets that became thin clients for someone else's orderflow stopped being businesses. Everyone nodded sagely. The appliance industry is about to run the identical experiment with physical hardware and a ten-year replacement cycle.

The DA Argument, Resolved by a Webcam

I have argued for two years that data availability layers are oversold, because the overwhelming majority of rollups do not produce enough data to justify dedicated availability infrastructure. The smart home finally gives me a clean test case.

Estimate a household's daily data. A few hundred sensor readings, a handful of automation events, a few thousand tokens of agent conversation. Aggregate that across a busy home and you are in the low megabytes per day. That is not a data availability problem. That is a rounding error on a rounding error.

Now add cameras. One 1080p stream running continuously at a modest 4 Mbps produces roughly 43 gigabytes per day, before any indexing, transcription, or embedding generation. Turn on natural-language search across video history, as one of these platforms has, and you are storing frames, generating embeddings, and maintaining an inverted index over a corpus that grows by tens of gigabytes per household per day.

The DA conversation was always about video, and nobody wanted to say so out loud, because video is a legal problem rather than a bandwidth problem. Rollup blobs for a DeFi protocol are a rounding error. Continuous home video with semantic search is the only workload in this entire sector that produces real availability pressure — and it arrives wrapped in the most sensitive data category a household can generate.

Which is why the compliance question is not a footnote. It is the main event.

The $19.99 Fairy Tale

Here is a comparison that crypto readers will find uncomfortably familiar. Aave and Compound publish interest rate curves with a kink at a utilization threshold, and those curves are presented as market-derived. They are not. They are governance parameters that someone typed in, then backtested until they looked defensible, then ratified by a token vote. Real supply and demand discovery is a distant cousin, not a parent.

$19.99 a month is the same object. It is not derived from inference cost, tool call volume, or household usage distributions. It is a number chosen for psychological adjacency to other consumer subscriptions, then reverse-engineered into a margin story. An agent running forty multi-step planning loops a day, each touching cloud inference and several third-party tool calls, has a cost profile that $19.99 may or may not cover — and the only honest answer is that nobody has published the unit economics to find out.

The moment inference becomes the margin line, the pricing model has to become metered. Subscription is a transitional fiction that works while usage is low and breaks the instant agents become genuinely useful. That is the same failure mode as an algorithmic rate model that looks elegant in a whitepaper and inverts the first time utilization spikes.

Capabilities Without Royalties

One more parallel, and this one is bitter. When the largest NFT marketplace made creator royalties optional, the creator economy on-chain did not adapt. It collapsed into a handful of headline collections and a long tail of abandoned projects, because there was no mechanism to enforce a secondary claim on value transfer.

Appliance makers are now in the creator position. They author the capability — the ability to preheat an oven correctly, to detect a failing compressor, to sequence a wash cycle around solar output. That capability is real intellectual property. And when it gets called through someone else's agent, there is no protocol-level royalty, no attribution, no rev-share. The value flows to the platform, and the hardware manufacturer is compensated through a device sale that happened three years ago.

On-chain, we at least built the machinery — split contracts, on-chain attribution, programmable secondary claims. It mostly failed for cultural and UX reasons, not technical ones. The appliance industry does not even have the machinery. It is about to discover why that matters.

The Angle Nobody Is Trading

The consensus read on this whole transition is that Apple is losing and the cloud platforms are winning. I think that is half right and strategically backwards on the half that matters.

Start with the observation that everyone treats as a weakness. Apple processes roughly 95% of certain workloads locally and treats the device as the trust boundary. In a vacuum, that is a capability handicap. In a world where household AI data is about to become a regulated category, it is the only architecture that scales without a legal department attached to every feature.

Searchable video history inside a home is not a product feature with a privacy disclaimer. It is a high-risk processing activity, and the regulatory surface it creates is substantial. Legal regimes governing personal data increasingly require a lawful basis, purpose limitation, retention limits, and — for the most sensitive categories — impact assessments. A cloud index of everything a family's cameras have ever seen, queryable in natural language, is precisely the kind of processing that attracts enforcement attention. The same applies to training usage of household data, cross-border transfer of that data, and the consent rights of people who live in the house but did not buy the device: children, partners, guests.

None of the flagship agentic home announcements have addressed any of it. Not the retention policy, not the training policy, not the third-party consent problem. That silence is not an oversight. It is the standard order of operations in consumer technology: ship the capability, litigate the boundary later.

Now the part that connects to what we build. Apple will not build the payment rail for agent-to-device calls. It will not ship a tool manifest with price, receipt, and attestation fields, because that is a crypto-shaped solution and Apple does not do crypto-shaped solutions. But the absence I inventoried earlier — no payer, no receipt, no attestation, no liability clause — is a live problem for every cloud-native platform too, and it gets worse as agents start spending real money on behalf of households.

The middleware that solves it already exists in fragments. Pay-per-call rails that let an agent settle a micro-payment before a tool executes. Account abstraction so a device or an agent can hold a policy-bounded wallet without a seed phrase in a kitchen drawer. Hardware attestation and verifiable execution so a receipt can prove which code ran, not just that something ran. Household policy expressed as a spend limit with a revocation path, auditable after the fact.

Put those together and you get something nobody in the smart home industry is currently shipping: an agent that can prove it paid, prove what it executed, and prove it stayed inside the limits the human set. That is not a crypto feature. That is the actual requirement, and crypto happens to be where the primitives live.

The contrarian call, stated plainly: the winner of the agentic home will not be the platform with the best model. It will be the platform that solves the accounting problem first, because capability without accountable execution does not survive contact with a regulator or an insurance underwriter. Apple is closer to that architecture than its competitors and further from the product. Crypto is closer to the primitives than anyone and further from the distribution. Somebody is going to occupy the middle.

There is a second, quieter tell I want on the record. The metric inflation I opened with — 1,000 against 140,000 with a shrug — is going to happen again to every agentic home statistic that gets published over the next two years. "Devices supported" will mean something different on every slide. "Agent actions per day" will count retries, or not. "Households enabled" will quietly exclude anyone who installed and bounced. Chaos is just data waiting to be organized, but only if you refuse to organize it in the shape the vendor handed you.

What to Watch

The signal I am tracking is narrow and mechanical, which is the only kind of signal worth tracking.

Watch the tool manifests. If a price field, a settlement hook, or an attestation reference appears in a published agent-to-device interface specification, the accounting problem is being solved in public and the meter is being installed. If eighteen months pass and the schemas still describe only capabilities and arguments, the entire agentic home thesis is running on subsidy, and subsidy always ends.

Watch the disclosure, not the demo. Subscription conversion rates, per-household inference cost, and third-party tool call volumes are the three numbers that determine whether any of this is a business. When they show up in a filing before they show up in a keynote, the industry has grown up.

Watch the compliance calendar more than the product calendar. The first serious enforcement action against searchable household video indexing will reprice every cloud-native agent architecture overnight and revalue local-first designs in the opposite direction. Speed reveals what stillness conceals — and regulation is the slowest moving actor with the fastest repricing power in this entire stack.

The socket is being installed. The question is whether the meter gets installed next to it, or whether an entire industry ships the capability and quietly hands the bill to someone who never agreed to pay it.