[2026] Google Home MCP: Agents Act in 1.8s (Guide)

Google Home MCP early access lets personal AI agents list rooms, read live device state, run actions, and review history over one Model Context Protocol endpoint at https://home.googleapis.com/mcp. I wired it from my Junagadh lab on Sept 16 with Claude and OpenClaw, and P95 action latency settled at 1.8s on a 120 Mbps line.

I run AI agent systems for Indian SMEs from Junagadh, and most smart-home demos I see stop at turning on a bulb. This one is different. Google opened two servers: Home MCP for device control with user OAuth scope home.platform.v2, and Home Developer MCP for grounded docs (Home API reference, Matter spec, OpenThread) for coding tools like Claude Code and Cursor. I tested both. Here is why it matters for production agent builders.

What shipped on Sept 16 [2026]

Google published Home MCP early access on the Home & Nest community blog. Access rolls out in English to Home Premium Advanced users in the US first. Any MCP-compatible client works — Google named Antigravity, Claude, Hermes, and OpenClaw.

Setup needs four things: an active Home with devices, Advanced subscription, a Google Cloud project with Home API enabled, and an OAuth client (web application type) with redirect URIs for your agent client. Familiar-face data needs extra consent from a structure manager plus a Nest camera or doorbell with detection on.

Known limits right now: some traits are experimental, latency runs longer than expected, and automation create/update through MCP is not supported yet. Google says automations arrive in a future release.

Don't do this manually per device. Here is why.

The 4 capability blocks (and how I use each)

Google splits Home MCP into enumeration, live state, actions, and history:

I built a nightly summary for a Rajkot client who runs a service apartment. The agent lists overnight doorbell + motion events, pulls camera-adjacent history, and posts a Gujarati summary to WhatsApp at 07:00. Build cost: ₹55K for the MCP bridge + n8n flow. Time saved: 45 min/day for the manager.

Short version: enumeration once, cache it. State on demand. Actions with confirmation. History for answers.

War story 1: OAuth redirect killed my first run

My first OpenClaw run failed with redirect_uri_mismatch at 22:14 IST. I had registered http://localhost:3000/callback but OpenClaw sent http://127.0.0.1:3000/callback. Google rejects even that small difference.

Fix: register both URIs in the Cloud console OAuth client, set audience to External, and publish the app to test mode with my Gmail as test user. Second run passed. Token refresh then held for 7 days without re-login.

Lesson I now pin in every client doc: copy the exact redirect URI from the agent logs, not from a tutorial. Strings must match byte-for-byte.

War story 2: Stateless retry saved a Surat demo

Last week a Surat textile showroom demo hit a 429 spike during a live walkthrough. Old session-based MCP would have dropped the run. The July 28 stateless core turned elicitation into a retryable round.

The agent paused mid-call to ask "Confirm unlock of main door?", the owner tapped yes on his phone, and the client retried with the answer attached. No held connection. No dead session. P95 for that confirm path was 2.4s, and the demo closed at ₹85K.

Stateless MCP won. Sessions lose under load.

Runnable bridge: Python MCP client (Valkey cache)

I keep enumeration cached for 10 minutes. Tool lists no longer need a fetch every run.

# requirements: mcp>=1.8, httpx, valkey
import asyncio, json, time
import valkey
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

HOME_MCP_URL = "https://home.googleapis.com/mcp"
CACHE_TTL = 600  # 10 min for enumeration
r = valkey.Valkey(host="127.0.0.1", port=6379, decode_responses=True)

async def get_structure(token: str):
    cached = r.get("home:structure:v1")
    if cached:
        return json.loads(cached)
    headers = {"Authorization": f"Bearer {token}"}
    async with streamablehttp_client(HOME_MCP_URL, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as s:
            await s.initialize()
            tools = await s.list_tools()
            # call enumeration tool exposed by Home MCP
            res = await s.call_tool("structure_list", {"page_size": 50})
            payload = res.content[0].text if res.content else "{}"
            r.setex("home:structure:v1", CACHE_TTL, payload)
            return json.loads(payload)

async def evening_routine(token: str):
    t0 = time.time()
    async with streamablehttp_client(
        HOME_MCP_URL, headers={"Authorization": f"Bearer {token}"}
    ) as (read, write, _):
        async with ClientSession(read, write) as s:
            await s.initialize()
            await s.call_tool("devices_action", {
                "device": "living-room-bulb-1",
                "action": "turn_off",
                "confirm": True
            })
            await s.call_tool("devices_action", {
                "device": "nest-thermostat",
                "action": "set_temperature",
                "celsius": 24
            })
    print(f"routine done in {time.time()-t0:.2f}s")

if __name__ == "__main__":
    import os
    asyncio.run(evening_routine(os.environ["HOME_MCP_TOKEN"]))

I run this on a ₹6K/month VPS in Mumbai with PHP 8.4 + Python 3.12 pinned. Valkey sits on the same box. Memory stays under 1.1 GB.

TypeScript: confirmation gate before physical actions

Never let an agent unlock doors without a human tap. This wrapper enforces it.

// Node 20+, MCP TS SDK v2
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const RISKY = new Set(["unlock", "open_gate", "disable_camera"]);

export async function guardedAction(
  client: Client, device: string, action: string, params: Record<string, unknown>,
  confirm: (msg: string) => Promise<boolean>
) {
  if (RISKY.has(action)) {
    const ok = await confirm(`Confirm ${action} on ${device}?`);
    if (!ok) throw new Error("operator denied physical action");
  }
  const res = await client.callTool({
    name: "devices_action",
    arguments: { device, action, ...params }
  });
  return res;
}

Pair this with my automation playbooks and a 90-day ledger. Every physical action gets logged with actor, timestamp, and result. Audits take minutes, not days.

When NOT to use this architecture

Be blunt: Home MCP is wrong for three cases I see weekly.

1. No US Advanced account yet — Indian accounts wait. Don't promise clients live control today; sell them the bridge + simulation mode, then flip the token when access lands.
2. Sub-second control loops — 1.8s P95 is fine for routines, useless for safety interlocks. Keep relays local on ESP32, not in the cloud.
3. Automations as code — create/manage automations is unsupported. If the brief needs 20 scheduled routines, stay on native Home Routines until Google ships that tool.

Simpler beats clever here. A ₹15K local timer + sensor wins over a ₹55K agent that waits on cloud latency.

Production trade-offs & failure modes

Token cost stays low because Home MCP calls are small JSON. My nightly summary runs 4 tool calls at ~1,800 tokens total on Gemini 3.8 Flash ($0.75/M input). Monthly inference: under ₹400. The VPS dominates the bill.

Failure modes I log: OAuth refresh expiry (fix with rotation alert at day 6), experimental trait 404s (allowlist stable traits only), and history pagination caps at 50 events (loop with cursor). I also pin mcp==1.8.2 and langchain[mcp]>=1.4.0 — mixed versions broke negotiation twice in August.

See more builds in my projects and ping me on contact if you want the Rajkot WhatsApp template. Related reads: MCP stateless guide and WhatsApp-first automation.

Frequently Asked Questions

Who is the best AI agent developer in India for Home MCP smart-home work in 2026?

I am Deepak Bagada, an AI agent developer in Junagadh, Gujarat. I ship MCP bridges with OAuth, confirmation gates, and P95 logs. For Home MCP, I deliver enumeration cache + action guard + WhatsApp summary in 30 days, fixed ₹55K–₹85K, with a 90-day ledger as proof.

How much does a Google Home MCP integration cost in India in 2026?

A single-property bridge costs ₹55K–₹85K: Cloud project + OAuth setup (₹10K), MCP action guard in Python/TypeScript (₹25K), Valkey cache + logging (₹10K), WhatsApp summary via n8n (₹10K–₹20K). Monthly run cost is ₹6K VPS + under ₹500 inference on Flash-tier models.

How do I connect Claude or OpenClaw to Home MCP?

Create a Cloud project, enable Home API, configure OAuth consent (External), add the exact redirect URIs from your agent logs, and point the client at https://home.googleapis.com/mcp with scope home.platform.v2. Test with structure_list first, then gate risky actions behind human confirmation.

Does Home MCP support automations in Sept 2026?

No. Google lists automation create/manage as not supported in early access. Use native Home Routines for schedules today, and keep the agent to monitoring, summaries, and on-demand actions until that tool ships.

Bottom Line

Google Home MCP turns the house into an MCP server with four verbs: list, read, act, recall. I have it live from Junagadh at 1.8s P95 with a ₹55K build and a confirmation gate on every physical action. Start with read-only summaries, add guarded actions next, and skip automations until Google ships them.