Hosted MCP Events for your MCP server

Wakeshift serves SEP-3415 to the clients that subscribe, and wakes the coding agents that don't, from the same emit.

MCP Events (SEP-3415) is the protocol's draft extension for events: a client subscribes to one of your server's events, and your server delivers each occurrence to it. Adding it means answering events/list, events/subscribe and events/unsubscribe, and then running the rest: a store of subscriptions, signed deliveries with retries, renewals, and a queue for clients that poll. Some toolkits leave that part to you: Vercel's mcp-handler guide calls the store and delivery "application code, not an included adapter".

With Wakeshift, attach answers those requests on the MCP server you already run, mcp-handler included, and Wakeshift holds each subscription and delivers every occurrence. You define your events and call emit. The same emit also wakes the coding agents that don't subscribe to MCP Events, such as Claude Code, Codex, Cursor and Copilot CLI, in the conversation that asked.

Try it in two minutes, no sign-up · Read the quickstart

Add it to your MCP server

Install @wakeshift/sdk, define your events once, then attach in the function that builds the server. On Vercel's mcp-handler, attach the same way on the server its createMcpHandler hands you (MCP frameworks):

TypeScript
import { McpServer, createMcpHandler } from "@modelcontextprotocol/server"
import { z } from "zod"
import { Wakeshift } from "@wakeshift/sdk"

const wake = new Wakeshift({ key: process.env.WAKESHIFT_KEY! })

const renderFinished = wake.defineEvent("render.finished", {
  description: "A video render finished",
  args: z.object({ render: z.string() }),
  payload: z.object({ status: z.string(), url: z.string() }),
  text: (r, { render }) => `Render ${render} ${r.status}: ${r.url}`,
  authorize: (subscriber, { render }) => ownsRender(subscriber.user, render),
})

const mcp = createMcpHandler(() => {
  const server = new McpServer({ name: "renders", version: "1.0.0" })
  // After the last defineEvent. identify names the user from your sign-in's verified token:
  // clients that subscribe natively need one.
  const attached = wake.attach(server, { identify: (ctx) => ({ user: userOf(ctx.http?.authInfo) }) })
  server.registerTool(
    "start_render",
    { description: "Render a video", inputSchema: attached.inputs(z.object({ scene: z.string() })) },
    attached.events("start_render", { subscribes: [renderFinished] }, async ({ scene }, call) => {
      const render = await startRender(scene) // an ID your app made, such as "r-5120"
      await call.subscribe(renderFinished, { render })
      return `Render ${render} started. You'll hear back when it's done.`
    }),
  )
  return server
})

When the render ends, wherever your backend learns it:

TypeScript
await renderFinished.emit({ render }, { status: "done", url })

Clients that subscribe natively get render.finished through MCP Events, and start_render's reply tells them what to subscribe to; every other agent is subscribed by call.subscribe. Your code is the same for both. MCP frameworks lists the others Wakeshift runs on, from the official TypeScript, Python and Go SDKs to Cloudflare and Mastra.

What Wakeshift runs for you

The part What Wakeshift does
Subscriptions Holds each one for your signed-in user. Your event's authorize runs before it starts, and again on every poll. Each user can have up to 20 webhook subscriptions to your app at once.
Webhook delivery Checks that the client's URL agrees to receive events, then sends each occurrence as one POST signed with Standard Webhooks, in order, retried for up to 15 minutes.
Poll delivery For clients that can't take webhooks: each poll returns what happened since the last one, in order, and nothing is lost between polls or when one fails. A subscription nobody polls for 10 minutes ends.
Renewal and ending A webhook subscription lasts at most a day unless the client renews it. Your users can see and stop theirs by asking their agent, and removing an event from your app ends its subscriptions.
The draft and its clients Follows the current draft and, where a client differs from it, stays compatible with the client. Tested end to end with OpenClaw, Hermes Agent, Mastra, TanStack AI and the Vercel AI SDK, on apps built with Wakeshift's TypeScript and Go SDKs.

MCP Events is defined for MCP protocol 2026-07-28: Wakeshift's Go and Python SDKs speak it, and its TypeScript SDK does on a stateless transport.

Who subscribes, and the agents that don't

The clients that subscribe include ChatGPT's Work chats (on Business or Enterprise) and dots, OpenClaw, Hermes Agent, Mastra, TanStack AI and the Vercel AI SDK. Each event starts a new run in them, or runs your code; Mastra's signal provider instead adds it to the thread that subscribed. The main local coding agents don't subscribe to another company's server: Claude Code, Cursor, Copilot CLI and opencode don't subscribe at all, and Codex only to OpenAI's own connectors. The draft is still in review, and it's an extension: once it's in the spec, each client still chooses whether to support it.

The same emit reaches the coding agents. They subscribe through your tool, or the subscribe_events tool attach adds, and Wakeshift wakes the conversation that asked, the way each agent can be woken: Claude Code, Codex, Cursor, Copilot CLI, opencode and Antigravity CLI while idle, most within seconds. Some need a one-time install the agent offers, and some ask before the command that waits (what each agent asks). OpenClaw and Hermes Agent can do both: MCP Events for an automation that runs on its own, and Wakeshift's plugin for the conversation the user is in.

When you don't need this

Next