# The state of MCP Events: client support in November 2026

MCP's core maintainers accepted the Events extension ([SEP-3415](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/3415)) this week. It lets an MCP server tell an agent the moment something happens: a job finishes, a person replies, an alert fires. If you're adding events support to your MCP server, your first questions are likely which clients will subscribe to your events and what each one does when an event arrives.

The day before, Sentry's co-founder David Cramer [wrote](https://x.com/zeeg/status/2120224571689484639) about MCP Events:

> These seem like a great idea, but they're largely not usable today. Either they're not implemented or they're implemented in such a domain specific way that its hard for you - the author of an MCP server - to rely on them for any customer facing behavior.

He's right. We went through each client's current release. The main coding agents can't subscribe, and the clients that can were built against earlier drafts, so a server that follows the spec exactly works with almost none of them.

But you don't have to wait for the clients to catch up. A server that allows for each client's differences can serve all of them today. [Wakeshift does that for you](https://wakeshift.ai/blog/state-of-mcp-events-2026-11#how-to-ship-events-now), and wakes the agents that can't subscribe as well.

**Note:** client support changes almost daily. [Hosted MCP Events](https://wakeshift.ai/mcp-events) is the page we keep up to date.

## What we found

- **The main coding agents can't subscribe, so a user in any of them never hears your events.** Claude Code and Codex CLI have no support, and VS Code, Cursor and GitHub Copilot CLI don't mention it. opencode has it behind an experimental flag.
- **Six clients do subscribe, but a server built to the spec works with almost none of them.** ChatGPT's Work chats, OpenClaw, Hermes Agent, the Vercel AI SDK, Mastra and TanStack AI were mostly built against earlier drafts. Three read only the old capability key, so a server that advertises the spec's key looks to them like it has no events. Four reject a webhook whose `webhook-id` follows the spec. Five don't send the `Mcp-Name` header the spec tells you to require. You end up building for each client instead of for the spec.
- **A delivered event often doesn't reach the conversation that asked.** OpenClaw and Hermes Agent start a separate run, and the conversation the user has open never sees it. The three libraries hand the event to the app's code. So the person who asked may not get the answer where they asked.
- **Almost all of them take events only by webhook, so your server has to offer webhooks.** That means running a subscription store, signed deliveries, retries and renewals. It also means the agent has to be reachable by inbound HTTPS: a local agent on a laptop without a public address can't receive them.

The tables and the detail behind each point are further down.

## How to ship events now

Wakeshift is a hosted service that lets an MCP server wake the AI agents that use it. You define your events and call `emit` using our SDK, which works with most major MCP server libraries. Wakeshift handles the rest:

- **It wakes the agents that can't subscribe.** Claude Code, Codex, Cursor and Copilot CLI wake in the conversation that asked, from the same `emit`.
- **It serves each client the way that client expects,** including the ones built on earlier drafts.
- **It delivers by webhook, poll and push,** and runs what sits behind them: the subscription store, signed deliveries with retries, and subscriptions that end unless the client renews them.
- **It keeps up as the clients change.** You ship once, and your code stays the same when a client moves to the finalized specification.

[Add it to your MCP server](https://wakeshift.ai/docs/quickstart), or read [how hosted MCP Events works](https://wakeshift.ai/mcp-events).

## Who subscribes to a third-party server's events

"Subscribes" means the client itself calls your server's `events/*` methods, for a server its user added. Clients come in two kinds, and they handle an event differently:

- **Agents** are the apps people use, such as Claude Code or OpenClaw. The agent subscribes for its user, and decides itself what happens when an event arrives.
- **Libraries** are what developers build their own agents with, such as the Vercel AI SDK. A library subscribes when the app's code asks, and hands each event to that code, which decides what to do with it.

Each row names the release we checked, and a cell says unverified where we couldn't confirm something.

### Agents

| Agent | Release checked | Subscribes | Delivery | When an event arrives |
| --- | --- | --- | --- | --- |
| ChatGPT: Work chats (on the web, and in the desktop app with Cloud selected) and dots | [OpenAI's guide](https://developers.openai.com/plugins/build/mcp-events), which has no version or date | Yes | Webhook | The event goes to the chat that subscribed, and ChatGPT follows the instructions the user gave when subscribing. It can handle several events in one task run |
| Claude Code | 2.1.325 (2026-11-13) | No | | Neither the changelog nor the MCP docs mention MCP Events. A request to start routines from them ([#101434](https://github.com/anthropics/claude-code/issues/101434)) has been open since 2026-10-12 with no reply from Anthropic |
| VS Code | 1.146 (2026-11-11) | No mention | | Neither the release notes nor the MCP docs mention MCP Events |
| Cursor | Changelog up to 2026-11-06 | No mention | | Its MCP docs list tools, prompts, resources, roots, elicitation and apps, but not events |
| Codex CLI | 0.169.0 (2026-11-13) | No | | Neither the release notes nor the MCP docs mention MCP Events, and we found no `events/*` client in its source. OpenAI's guide doesn't name Codex. Whether any Codex session takes events is unverified |
| OpenClaw | 2026.11.3 (2026-11-10), its first stable release with events | Yes, with the bundled `mcp-events` plugin turned on | Webhook | It runs the automation that owns the subscription, as a separate run with the automation's instructions and the event as untrusted data. The conversation the user has open doesn't see it |
| Hermes Agent | v0.23.1 (2026-11-10) | Yes, with `events: true` on the server in its config | Webhook | The model subscribes with its `subscribe_event` tool once the user approves. Each event starts a new, unattended run with the instructions given at subscribe time. The conversation that subscribed doesn't see it. We read the source at v0.23.1 and ran v0.22.5 |
| opencode | v2.3.0 (2026-11-13), OpenCode 2 ([#63254](https://github.com/anomalyco/opencode/pull/63254), [#63269](https://github.com/anomalyco/opencode/pull/63269)). OpenCode 1, which its default installer gives, has none | Yes (experimental), with the `mcp_events` flag turned on | Push (`events/stream`) | The model calls a `watch_mcp_event` tool, and each event wakes the session that's watching. The watch ends after one event unless the model asks for more. Unverified end to end: we haven't run it with a model |
| GitHub Copilot CLI | 1.0.111 (2026-11-13) | No mention | | Its recent release notes don't mention MCP Events |

### Libraries

| Library | Release checked | Subscribes | Delivery | When an event arrives |
| --- | --- | --- | --- | --- |
| Vercel AI SDK (`@ai-sdk/mcp`) | 2.0.99 (2026-11-13) | Yes (experimental) | Webhook | The app's callback runs. An agent run starts only if the app's code starts one |
| Mastra (`@mastra/mcp`) | 2.9.0 (2026-11-12) | Yes (experimental) | Webhook if the app sets one up, otherwise push, then poll | In code, the subscription yields each event. Its `MCPEventsSignalProvider` passes the event to the agent threads subscribed to it, as untrusted data. We haven't run the signal provider, so that part is unverified |
| TanStack AI (`@tanstack/ai-mcp`) | 1.2.0 (2026-11-09) | Yes (experimental) | Webhook | The app's callback runs. An agent run starts only if the app's code starts one |

Nearly every client that subscribes does it by webhook. ChatGPT's Work chats, OpenClaw, Hermes Agent, the Vercel AI SDK and TanStack AI take nothing else. Mastra is the only one that polls, and opencode's client is push only.

The spec doesn't say what a client should do with an event (its first open question is how events reach the model), so each client decides. An event starts a separate run in OpenClaw and Hermes Agent, goes to the subscribing chat in ChatGPT's Work chats, and runs application code in the three libraries. Only opencode's experimental client and Mastra's signal provider deliver it into the conversation that subscribed.

So write each event to stand on its own. In OpenClaw and Hermes Agent, the run that reads it never saw the conversation that subscribed, and has only the instructions saved with the subscription. Say what happened and to what, and let the agent call your tools for the rest.

## Where the clients differ on the wire

This table covers the seven clients that subscribe. "Spec" is the accepted text, at commit [`f77a5fe`](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/3415/commits/f77a5fe31b91c052dbfc2a37add98b9e84662b34).

| Client | Capability key it reads | Sends Mcp-Name on events requests | A webhook-id that differs from eventId | gap and terminated |
| --- | --- | --- | --- | --- |
| Spec | `extensions["io.modelcontextprotocol/events"]` | Required | Required | A receiver must pass both on to its client |
| ChatGPT: Work chats and dots | Top-level `events` (documented) | No | Documented as "the same value as the body's `eventId`". A mismatch gets HTTP 400 | Not supported (documented) |
| OpenClaw 2026.11.3 | Top-level `events`, from `server/discover` only | No | Rejected with HTTP 400 | Both rejected with HTTP 400 |
| Hermes Agent v0.23.1 | None. Events are turned on per server in its config | No (a fix is open: [#151565](https://github.com/NousResearch/hermes-agent/pull/151565)) | Accepted (run on v0.22.5) | Both handled (run on v0.22.5) |
| opencode v2.3.0 | `extensions` | Yes, on stream, poll, subscribe and unsubscribe | No webhooks | `terminated` ends the watch |
| Vercel AI SDK 2.0.99 | Top-level `events` only | No | Rejected with HTTP 400 | Both handled |
| Mastra 2.9.0 | `extensions` only | No | Accepted | Both handled |
| TanStack AI 1.2.0 | `extensions` only | Yes, on `events/subscribe` and `events/unsubscribe` | Rejected with HTTP 400 | Both handled |

That table is the short version. A server that works with every client also needs a subscription store, signed deliveries with retries, renewals, poll and push, and a different answer for some clients on the capability key, `webhook-id`, `Mcp-Name` and error codes.

## Where MCP Events goes from here

The core maintainers accepted the standard on November 11, and its wording is being finished. Spec releases now come in March and September, so Events can be in a spec release in March 2027 at the earliest. It's an extension, so each client still decides whether to support it.

The clients have the most to do. The main coding agents don't subscribe yet. The clients that do subscribe were built against earlier drafts and have to move to the spec's capability key, `Mcp-Name` and `webhook-id`. Each also decides how an event reaches the model, which the spec leaves open. opencode shows one answer: its 2.3.0 release wakes the session that's watching, behind its experimental `mcp_events` flag. Its default install is still opencode 1.19.x, which has no events client.

Servers have work too. No official MCP SDK ships Events yet. The Python SDK has an open pull request and the TypeScript SDK a proposal, so until they land, every server builds its own subscription store and delivery.

This is heading toward one standard way for an MCP server to tell an agent that something happened, which every client reads the same way. Until the clients get there, Wakeshift lets you ship events today.

---

**Wake your users' agents when your events happen.** Define your events and call emit, and Wakeshift wakes the agents your users already run, Claude Code and Codex included. [Read the quickstart](https://wakeshift.ai/docs/quickstart)
