The wake-up call for AI agents.

Your app wakes AI agents the moment something new happens, with a few lines of code on the MCP server you already run.

Backed by Y Combinator

An event in your app wakes an agent A crawl of example.com that your app started finishes, and your app emits the crawl.finished event. Wakeshift delivers it to a sleeping agent (Claude Code, Codex or Cursor, in turn), which wakes, reads "Crawl of example.com finished: 1834 pages", and writes up what changed. YOUR APP example.com Crawl · 1834 pages done crawlFinished.emit({ site: "example.com" }, …) Wakeshift THEIR AGENT Claude Code Codex Cursor idle awake z z z Waiting for the crawl to finish EVENT FROM CRAWLER Crawl of example.com finished: 1834 pages Reading the pages with get_crawl and writing up what changed.

Use this prompt to get started.

Add Wakeshift to this MCP server following https://wakeshift.ai/AGENTS.md

Integrates with the stack you already use

Wakes the agents your users already run

  • Claude Code, Claude Cowork
  • Codex
  • Cursor
  • Copilot CLI
  • opencode
  • Antigravity
  • pi
  • Hermes Agent
  • Grok Bot
and any MCP client
How it works

Your users add your MCP server normally, then you can wake their agents

  1. Step 1

    Your user adds your app

    They don't sign up for Wakeshift or click through a Wakeshift screen. Adding your app is the consent.

  2. Step 2

    Their agent subscribes

    The tool that starts the crawl subscribes the conversation that called it, or the user asks their agent to watch something.

  3. Step 3

    You emit, and it wakes

    Your backend calls emit when the crawl is done. The conversation that asked picks up, with your event marked as coming from your app.

Use cases

For work that finishes after your tool returns

Your MCP tool returns right away, but the work it starts can run for minutes, hours or days. When the agent hears back, that work reaches your user, and your product finishes what it started.

On your server

Three calls on the MCP server you already have

  1. defineEvent

    Name what your app offers, with typed arguments and payloads.

  2. attach

    Agents can subscribe through your server, whichever program they run in.

  3. emit

    Call it from anywhere in your code, and every subscriber wakes.

Your tools can subscribe too. Have your start_crawl tool subscribe the conversation that called it, and the agent hears back when the crawl is done, with nothing more for the user to ask. See the tool

server.ts
import { createServer } from "node:http"import { McpServer, createMcpHandler } from "@modelcontextprotocol/server"import { toNodeHandler } from "@modelcontextprotocol/node"import { Wakeshift } from "@wakeshift/sdk"import { z } from "zod"const wake = new Wakeshift() // reads WAKESHIFT_KEYconst crawlFinished = wake.defineEvent("crawl.finished", {  description: "A site crawl finished",  args: z.object({ site: z.string() }),  payload: z.object({ pages: z.number() }),  text: (crawl, { site }) => `Crawl of ${site} finished: ${crawl.pages} pages`,  public: true, // open to every agent, not only your tools})const mcp = createMcpHandler(() => {  const server = new McpServer({ name: "crawler", version: "1.0.0" })  wake.attach(server) // agents can now subscribe  return server})createServer(toNodeHandler(mcp)).listen(3000)// When the crawl finishes, wake every agent waiting on itawait crawlFinished.emit({ site: "example.com" }, { pages: 1834 })
$ npm install @wakeshift/sdk @modelcontextprotocol/server @modelcontextprotocol/node zod
What you get

Everything between your event and a woken agent

You decide what happens in your app. Wakeshift handles your users, their agents, and every delivery in between.

Works with the agents your users run

Claude Code, Codex, Cursor, Copilot CLI, ChatGPT's Work chats and more, each woken the way it can be. Your code is the same for all of them; most need nothing installed, and the rest ask once.

Works with your MCP server

Wakeshift plugs into the MCP server you already publish, sign-in and all. Your users connect exactly the way they do today.

Emit from anywhere

From the code that finishes the job, a queue consumer or a webhook handler you already have. Or point a service at a publish URL, and each post that matches your event emits, with no handler of yours.

Agents know who's talking

Every event arrives marked as coming from your app, so agents treat it as information, not as orders from their user.

Your users consent once

Adding your app is the consent. A subscription starts only when a user asks, an event can go privately to one user, and every consent and revocation is in an audit log.

Nothing gets lost

Events wait for agents that are offline. Your dashboard shows every event you send and every delivery.

Pricing

Start free, and pay as your app grows

Every plan includes 50,000 deliveries a month. Retries, filtered events and events no agent is subscribed to never count.

Free

$0

Build and try your app, with 50,000 deliveries a month.

  • 50,000 deliveries a month
  • 10 deliveries a second
  • 7 days of event history
Sign up

Starter

$29a month
+ $0.10 per 1,000 deliveries

Run your app in production, and pay as you go past the included usage.

  • 50,000 deliveries a month included
  • 50 deliveries a second
  • 30 days of event history
Get started

Custom

Custom

For apps at scale, on terms agreed with you.

  • Volume discounts and custom throughput
  • SSO and data residency
  • A named contact
Contact us

A delivery is one event reaching one agent. Compare plans

Start building

Add it to your MCP server in five minutes.

Building an MCP server

The quickstart adds events to the server you already run and wakes an agent with one. It takes about five minutes.

Read the quickstart

Just trying it out

Get a webhook URL that wakes your own agent whenever something posts to it. No sign-up, and no server of your own. Or connect your agent to one of our example apps.

Test a wake

Questions about your app? Talk to us.