Google Home MCP Server: how ChatGPT and Claude control lights with JSON

The user tells Claude “set the living room light to 80.” The Host does not send that sentence to the bulb. It first lets the model pick an MCP tool, then emits a tools/call. Google’s server recognizes the tool name and the parameter object. Unrecognized keys, an invented device id, brightness written as "八十" — none of those should become a physical action. Why the contract layer is an object: Why AI likes JSON.

What Google actually opened

As of 2026-09-28, public material is two MCP surfaces. Do not mix them:

• Home MCP: talks to a real house. Early Access. Needs Google Home Premium Advanced, a Cloud project, Home API enabled, OAuth. Official named clients: Antigravity, Claude Cowork, OpenClaw. The press note also named ChatGPT and Hermes. The server endpoint is https://home.googleapis.com/mcp.
• Home Developer MCP: docs, Matter specs, Home API samples. For people writing integrations, not for turning off your lights. This piece does not cover it.

Product manager Taylor Lehman’s gist: any MCP-capable Agent can safely use devices and event history in Google Home. Capabilities include reviewing across cameras, counting washer cycles from state history, pushing a spoken line to a speaker after a task, and letting an Agent draw a custom dashboard. This does not replace Gemini for Home. That is the official assistant on the Home App and Nest speakers. MCP is a third bus: your own Agent reaches in.

Limits sit on the same page. United States, English, Premium Advanced (about $20/month or $200/year), rolled out over weeks from 16 September. Official known issue: Nest Aware Plus users may be wrongly admitted; a fix is still in progress. Automation create and manage is “coming soon”; it is not here now. Familiar faces need a separate consent link; ordinary OAuth does not open that. How Antigravity wires MCP: the Antigravity September update.

Wiring: URL, SSE, OAuth

Official onboarding pins the production URL:

{
  "mcpServers": {
    "home_mcp": {
      "serverUrl": "https://home.googleapis.com/mcp",
      "oauth": {
        "clientId": "YOUR_CLIENT_ID",
        "clientSecret": "YOUR_CLIENT_SECRET"
      }
    }
  }
}

The same page’s “let the assistant configure itself” prompt also shows https://preprod-home.sandbox.googleapis.com/mcp, transport sse, scope https://www.googleapis.com/auth/home.platform.v2. Accept a production connection against home.googleapis.com/mcp. Do not put the sandbox URL in user docs.

OAuth is not optional. Build a Web application client in Cloud Console and fill the Host callback:

• Antigravity: https://antigravity.google/oauth-callback
• Claude Cowork: https://claude.ai/api/mcp/auth_callback
• OpenClaw: the redirect URI from the local install

The app must be Published. In the browser, pick a structure, authorize, hand the code back to the Host. Permissions can be revoked anytime in the Google Home App or My Accounts. This section is not about whether parameters are legal. No token, none of the five tools appear. With a token, bad arguments can still leave — that is the next section.

Five tools, not one universal switch

The official capability table only lists five names. The onboarding page does not paste a full inputSchema. At landing, ask the server for tools/list and treat that JSON Schema as ground truth. The names already split the “one universal home tool” idea:

1. list_homes: structures and houses the current account can see.
2. list_home_resources: rooms, devices, traits, attributes, and command schema.
3. list_home_states: live online and trait state.
4. run_home_actions: run parameterized actions on a target device. This is the only entry that changes physical state.
5. list_home_history: query state changes and events by time range.

Official acceptance prompts also split these five layers: “how many lights are in the house,” “is the house locked,” “turn off the outdoor lights,” “what happened while I was out.” The model should not skip list_home_resources and invent a device id. That skipped call should go red on Schema. Where MCP sits in the tool table: Agents API vs MCP.

The arguments before the light moves

The Host emits standard MCP JSON-RPC. Trust the names your client actually sees; pin a shape like this for acceptance:

{
  "jsonrpc": "2.0",
  "id": 17,
  "method": "tools/call",
  "params": {
    "name": "run_home_actions",
    "arguments": {
      "structure_id": "home_12a4",
      "actions": [
        {
          "device_id": "light.living_room",
          "command": "Brightness",
          "params": {
            "brightness": 80
          }
        }
      ]
    }
  }
}

This object looks like it can dim a light. It can still point at the wrong house, a deleted device, or a command the platform will not run. Pin the contract first, then let the model fill numbers:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "additionalProperties": false,
  "required": ["structure_id", "actions"],
  "properties": {
    "structure_id": { "type": "string", "minLength": 1 },
    "actions": {
      "type": "array",
      "minItems": 1,
      "maxItems": 8,
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": ["device_id", "command", "params"],
        "properties": {
          "device_id": { "type": "string", "pattern": "^(light|thermostat|camera|lock|speaker)\\.[a-z0-9_]+$" },
          "command": { "type": "string", "enum": ["OnOff", "Brightness", "ThermostatTemperatureSetpoint"] },
          "params": { "type": "object" }
        }
      }
    }
  }
}

The device_id pattern and the command enum must be generated from the list_home_resources return at that moment. Do not hand-write “every light in the world.” Pin the shapes that must fail:

{
  "ok_shape": {
    "structure_id": "home_12a4",
    "actions": [
      { "device_id": "light.living_room", "command": "Brightness", "params": { "brightness": 80 } }
    ]
  },
  "wrong_type": {
    "structure_id": "home_12a4",
    "actions": [
      { "device_id": "light.living_room", "command": "Brightness", "params": { "brightness": "八十" } }
    ]
  },
  "invented_id": {
    "structure_id": "home_12a4",
    "actions": [
      { "device_id": "light.kitchen_that_does_not_exist", "command": "OnOff", "params": { "on": true } }
    ]
  },
  "extra_field": {
    "structure_id": "home_12a4",
    "actions": [
      { "device_id": "lock.front_door", "command": "OnOff", "params": { "on": false }, "extra_cmd": "Unlock" }
    ]
  }
}

Only ok_shape should leave. "八十", invented_id, and extra_cmd should fail local Schema. Official forbid-unlock is not a license for the Host to pass an object that smuggles Unlock. Fake tool names and out-of-scope parameters are the same class of risk; see malicious MCP / Fake Skills. How the intent layer judges whether a legal action should happen: Zero-Trust Agent.

Where ChatGPT, Claude, and Antigravity differ

The difference is the Host, not the tool table.

• Claude Cowork: official step-by-step. Add a custom connector under Connectors, URL https://home.googleapis.com/mcp, Client ID / Secret in Advanced settings, finish OAuth in the browser, turn on home_mcp in chat.
• Antigravity: put the mcpServers block above into MCP Config, then finish Authentication in settings and pick a structure.
• ChatGPT: TechCrunch listed ChatGPT among “MCP-capable Agents.” As of 2026-09-21, Google’s setup page has no ChatGPT callback URI and no “which cell to click in GPT.” The premise for wiring it: that ChatGPT product already hosts custom remote MCP, and you can fill the same production URL and the same OAuth client. Once connected, the model still sees those five tools, not a ChatGPT-private home API.

So the answer to “how ChatGPT and Claude control a smart home through MCP + JSON” is short: both act as MCP Host. The user authorizes a Google account once. Every later “turn off the light” is tools/call + run_home_actions. Do not write a separate arguments dialect per Host. Do fill a separate redirect URI per Host.

Familiar faces are a different door. Structure admin, Premium, Familiar face detection on each compatible camera, then the consent link with features=1. The Agent can help assemble the link. It cannot click agree for you.

The platform blocks unlock, not extra_cmd

The official Warning is blunt: once a real house is connected, the Agent will control devices for you. Home MCP has rate limits and forbids sensitive actions such as unlocking. The same paragraph then says: depending on your Agent, unexpected or unwanted behavior can still happen. If other people live there, tell them; or build a separate development structure.

Do not read those three sentences as “Google already validated my JSON.” The platform blocks a class of sensitive commands. It does not guarantee:

• brightness is a number, not "八十"
• device_id actually appeared in the latest list_home_resources
• arguments has no extra_cmd
• the model did not hammer the same light eight times

Experimental traits may be flaky, latency can run high — official Known Issues. None of that is a reason to skip Schema. The zero-trust piece judges intent; this piece’s door is shallower: wrong shape, no action. You need both layers; see every tool call still needs validation.

How to accept it in JSON Toolbox

1. Paste ok_shape and the three failing objects into JSON format. Confirm they parse.
2. Use JSON → Schema to generate a contract from a real tools/list, then add enum, pattern, and additionalProperties.
3. Run the same fields through MCP Tool. If a local function needs them too, wrap Function Calling.
4. Drop "八十", invented_id, and extra_cmd into Schema validator and confirm they fail. If the Agent’s final “light set to 80” also needs acceptance, use Structured Output separately — Home MCP owns the tool reach, not the final-reply contract.

Everything stays in the browser. Nothing is uploaded. First have an object that refuses bad arguments, then wire Claude or ChatGPT to home.googleapis.com/mcp.

FAQ

Do ChatGPT and Claude use two JSON dialects to control lights?

No. Same tools/list and tools/call. The difference is the OAuth callback and the connector UI.

Where is the full Schema for the official five tools?

Onboarding only names them. Treat the client’s tools/list as ground truth, then pin device / command / number types yourself.

Will Home MCP refuse bad parameters for me?

It blocks unlock and rate. Wrong types, invented ids, extra keys still need your Schema.

Are Home MCP and Home Developer MCP the same thing?

No. The former talks to a real house. The latter serves docs. This piece only covers the former.

Can I build automations with Home MCP now?

No. The 2026-09-21 page says not yet. Today you can list, read, run, and query history.

Summary

Google wired the house to a remote MCP. Claude already has official connector steps. ChatGPT was named in the press note; the setup page still has no separate row. Neither Host gets a private smart-home JSON. What you hold is still the five names inside tools/call, especially run_home_actions arguments. The platform blocks unlock. It will not refuse "八十" and extra_cmd for you. The next step is not a longer “please be careful with the lights” prompt. It is making an invented device id go red locally.

Related tools