MCP Events beat polling on reliability and token cost

The problem. MCP servers for products that perform substantial work or have unpredictable, periodic events are not well-suited to the MCP tool call paradigm. Today, polling is the most interoperable way to get events to an agent, but it's either unreliable or expensive, and often both.

Why now. The MCP Events proposal (SEP-3415), accepted on November 11, 2026, will allow standard MCP servers to declare and deliver events to clients that are subscribed.

What we tested. We ran two studies in Claude Code and Codex: one on external events whose timing is indeterminate, like inbound messages, and one on long-running jobs that take minutes or more.

What we found.

What it means. MCP Events are a natural fit for both long-running jobs and external events. Until agents and servers broadly support them, Wakeshift acts as a bridge.

Finding Without events With MCP Events
Events missed, watching one inbox up to 87% 0%
Job results the user had to ask for 21% 0%
Idle token cost while waiting for events baseline about 90% lower
Token cost of waiting on a job baseline 30–77% lower in most cases

Background

Today, MCP tool calls are expected to return content quickly and synchronously. MCP servers for products that perform substantial work or have unpredictable, periodic events are not well-suited to the MCP tool call paradigm.

There are a few existing workarounds, but most only work in particular harnesses. Claude Code, for example, can keep a tool call open for hours if the server sends progress, while Codex ends any tool call after 300 seconds. The most common approach is polling, where the MCP server starts the work and gives the agent an identifier to poll until the work is complete. It's common because it's the most interoperable approach, since it's viable from any agent that can call an MCP server.

MCP Events will allow standard MCP servers to declare and deliver events to clients that are subscribed. A client can receive them by webhook, by polling a feed, or over a stream it holds open. The MCP Events proposal (SEP-3415) was accepted on November 11, 2026, and isn't final yet. Today, only a handful of agents and servers support it.

How we measured

To support the case for widespread adoption of MCP Events, we ran two studies to measure how much events help for the classes of problems where they're well-suited. One was against external events whose timing is indeterminate, like error alerts, inbound messages or code-review approvals; we pre-registered its design and analysis before running it. The other was against long-running jobs, where the agent calls an MCP tool that starts work that takes minutes or more.

Because MCP Events are not widely supported today across either the client side in agent harnesses or in the MCP servers, we used Wakeshift to build support for events. On the agent side, in the runs using events, the harnesses (Claude Code and Codex) had the Wakeshift plugin installed to receive events. The server side of each study is described below.

We build Wakeshift, the bridge we used to run these studies. Costs are at API list price; on a subscription plan they show up as usage limits instead of a bill.

External events

Bottom line: with events, agents answered every reply within five minutes in both agents; every way of polling either missed replies or cost several times more.

In this study, we took several popular MCP servers where events happen unpredictably and asynchronously, including error alerts, inbound messaging and code review. For those servers, we copied their tool names, descriptions and responses into a local toy server to measure the behavior of agents when interacting with those systems. We incorporated Wakeshift to allow them to emit events, and then set up several experiments over two-hour windows (one hour in an initial screening round) where events would occur at different frequencies on 10 arrival schedules we fixed in advance, with every approach run on the same schedules. We repeated a sample of this test against the real MCP server and found that agents polled it more frequently, so our results likely understate the cost of polling in these scenarios, and may overstate how often polling agents gave up.

Waiting on external events, like a customer's reply, is harder for polling, because the agent must poll indefinitely. Across 10 two-hour sessions per approach, we sent 45 customer replies for the agent to watch for, and tried several strategies.

In Claude Code, an agent that polled the inbox saw every reply but cost about ten times as much as events while idle. Long-polling, where the agent holds a request open repeatedly, was cheaper, but substantially less reliable as the agent gave up after a few minutes. Checking the inbox on a 15-minute schedule saw everything, but most replies were answered late. In Codex, every polling approach missed about half the replies or more, and agents stopped checking in most sessions. With events, agents in both harnesses answered all 90 replies within five minutes, at $0.07 an hour in Claude Code and $0.015 in Codex.

Replies handled and cost per idle hour, by approach and harnessFor each approach, a bar for the share of every reply sent while it ran that was handled before the user had to ask, and a bar for the median cost per idle hour; rows that passed the pre-registered bar are shaded.Claude Codereplies handledcost per idle hourgets an event100%$0.07✓ the referenceClaude Code, gets an event handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.070 (median)holds the call open100%$0.10✓ passesClaude Code, holds the call open handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.096 (median)checks on a timer100%$0.33cost 5× eventsClaude Code, checks on a timer handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.331 (median)long-poll13%$0.07missed 87%Claude Code, long-poll handled before the user had to ask: 13% (of every reply sent while it ran) cost per idle hour: $0.075 (median)polls the inbox100%$0.69cost 10× eventsClaude Code, polls the inbox handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.686 (median)Codexreplies handledcost per idle hourgets an event100%$0.015✓ the referenceCodex, gets an event handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.015 (median)holds the call opennot possible: Codex cuts calls at 300 sasked to check every 15 min18%$0.11missed 82%Codex, asked to check every 15 min handled before the user had to ask: 18% (of every reply sent while it ran) cost per idle hour: $0.105 (median)long-poll36%$0.16missed 64%, cost 11× eventsCodex, long-poll handled before the user had to ask: 36% (of every reply sent while it ran) cost per idle hour: $0.163 (median)polls the inbox51%$0.08missed 49%Codex, polls the inbox handled before the user had to ask: 51% (of every reply sent while it ran) cost per idle hour: $0.083 (median)Replies handled and cost per idle hour, by approach and harnessFor each approach, a bar for the share of every reply sent while it ran that was handled before the user had to ask, and a bar for the median cost per idle hour; rows that passed the pre-registered bar are shaded.Claude Codereplies handledcost per idle hourgets an event100%$0.07✓ the referenceClaude Code, gets an event handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.070 (median)holds the call open100%$0.10✓ passesClaude Code, holds the call open handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.096 (median)checks on a timer100%$0.33cost 5× eventsClaude Code, checks on a timer handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.331 (median)long-poll13%$0.07missed 87%Claude Code, long-poll handled before the user had to ask: 13% (of every reply sent while it ran) cost per idle hour: $0.075 (median)polls the inbox100%$0.69cost 10× eventsClaude Code, polls the inbox handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.686 (median)Codexreplies handledcost per idle hourgets an event100%$0.015✓ the referenceCodex, gets an event handled before the user had to ask: 100% (of every reply sent while it ran) cost per idle hour: $0.015 (median)holds the call opennot possible (300 s limit)asked to check every 15 min18%$0.11missed 82%Codex, asked to check every 15 min handled before the user had to ask: 18% (of every reply sent while it ran) cost per idle hour: $0.105 (median)long-poll36%$0.16missed 64%, cost 11× eventsCodex, long-poll handled before the user had to ask: 36% (of every reply sent while it ran) cost per idle hour: $0.163 (median)polls the inbox51%$0.08missed 49%Codex, polls the inbox handled before the user had to ask: 51% (of every reply sent while it ran) cost per idle hour: $0.083 (median)

Customer replies over 10 two-hour sessions per approach. "Replies handled" and "missed" count every reply sent while the approach ran; cost per idle hour is at API list price. The next chart counts all 45 replies.

What happened to the 45 replies, by approach and harnessA stacked bar per approach: replies handled within 5 minutes, handled later, missed, and not observed after a session stopped early.answered within 5 minanswered latermissednot seenClaude Codegets an event45 in 5 minClaude Code, gets an event 45 in 5 min (of 45 replies)holds the call open45 in 5 minClaude Code, holds the call open 45 in 5 min (of 45 replies)checks on a timer10 in 5 min · 35 lateClaude Code, checks on a timer 10 in 5 min 35 late (of 45 replies)long-poll6 in 5 min · 39 missedClaude Code, long-poll 6 in 5 min 39 missed (of 45 replies)polls the inbox38 in 5 min · 7 lateClaude Code, polls the inbox 38 in 5 min 7 late (of 45 replies)Codexgets an event45 in 5 minCodex, gets an event 45 in 5 min (of 45 replies)holds the call opennot possible: Codex cuts calls at 300 sasked to check every 15 min6 in 5 min · 28 missed · 11 not seenCodex, asked to check every 15 min 6 in 5 min 28 missed 11 not seen (of 45 replies)long-poll12 in 5 min · 21 missed · 12 not seenCodex, long-poll 12 in 5 min 21 missed 12 not seen (of 45 replies)polls the inbox23 in 5 min · 22 missedCodex, polls the inbox 23 in 5 min 22 missed (of 45 replies)What happened to the 45 replies, by approach and harnessA stacked bar per approach: replies handled within 5 minutes, handled later, missed, and not observed after a session stopped early.answered within 5 minanswered latermissednot seenClaude Codegets an event45 in 5 minClaude Code, gets an event 45 in 5 min (of 45 replies)holds the call open45 in 5 minClaude Code, holds the call open 45 in 5 min (of 45 replies)checks on a timer10 in 5 min · 35 lateClaude Code, checks on a timer 10 in 5 min 35 late (of 45 replies)long-poll6 in 5 min · 39 missedClaude Code, long-poll 6 in 5 min 39 missed (of 45 replies)polls the inbox38 in 5 min · 7 lateClaude Code, polls the inbox 38 in 5 min 7 late (of 45 replies)Codexgets an event45 in 5 minCodex, gets an event 45 in 5 min (of 45 replies)holds the call opennot possible in Codexasked to check every 15 min6 in 5 min · 28 missed · 11 not seenCodex, asked to check every 15 min 6 in 5 min 28 missed 11 not seen (of 45 replies)long-poll12 in 5 min · 21 missed · 12 not seenCodex, long-poll 12 in 5 min 21 missed 12 not seen (of 45 replies)polls the inbox23 in 5 min · 22 missedCodex, polls the inbox 23 in 5 min 22 missed (of 45 replies)

All 45 customer replies under each approach, by what happened to them.

With several things to watch at once, polling got expensive: watching three streams cost 5 to 37 times as much as events while idle. Across all twelve polling setups we tried, in both agents and with one stream or three, events cut the idle token cost by about 90% in the typical case.

Long-running jobs

Bottom line: with events, no user had to ask for a result, and waiting on a job was cheaper in 12 of 14 cases, by half or more in 9.

For this study, we included popular MCP servers that execute long-running jobs. The categories of these servers include web crawling, web scraping, video editing, CI builds, AI video generation, an AI model runner, a research API and a second crawling API, each with an open source MCP server implementation. Because these servers don't yet support MCP Events, we ran modified local copies with Wakeshift installed to give them events, and set them up to emit when the jobs were completed using a watcher built into our test harness that delivered the vendor's own webhook payload when each job finished.

Waiting without events was less reliable. With events, no user had to prompt the agent for results (0 of 124 sessions). With the unaltered MCP servers, without events, users had to prompt the agent in 23 of 111 sessions, and in 18 of those the agent never reported the result at all. Most of those were servers that hold the call: Claude Code dropped a call that sent nothing, and Codex cut calls at 300 seconds.

Polling is the most interoperable way to get events to an agent, but it's either unreliable or expensive, and often both. Any agent can poll, but it depends on the agent's cooperation to keep the loop going, and agents often stop. Each poll is also a request to the model behind the agent, which rereads the whole conversation up to that point. Prompt caching softens this: frequent polls keep the conversation in cache, so most of each reread is billed at the cheaper cached rate. Even so, waiting by polling cost up to about four and a half times as much as waiting for an event.

A four-minute crawl in Claude Code took 20 requests and cost $0.31 in tokens before the agent could tell the user it was done. With an event, the agent made a few small requests up front, waited idle, and was woken once when the job finished: $0.09. The polling agent also found out late, because it only learned the job was done at its next check.

Cumulative cost of one wait, polling against eventsTwo lines: the median polling session climbs a step for every check; the median events session stays low until one wake at the end.$0.00$0.10$0.20$0.30$0.400100200300seconds of waitingjob donePolling, as shipped request 1 at 1 s: $0.013 so farPolling, as shipped request 2 at 4 s: $0.024 so farPolling, as shipped request 3 at 6 s: $0.036 so farPolling, as shipped request 4 at 9 s: $0.059 so farPolling, as shipped request 5 at 39 s: $0.071 so farPolling, as shipped request 6 at 41 s: $0.082 so farPolling, as shipped request 7 at 43 s: $0.104 so farPolling, as shipped request 8 at 105 s: $0.117 so farPolling, as shipped request 9 at 108 s: $0.129 so farPolling, as shipped request 10 at 110 s: $0.151 so farPolling, as shipped request 11 at 230 s: $0.164 so farPolling, as shipped request 12 at 232 s: $0.176 so farPolling, as shipped request 13 at 234 s: $0.198 so farPolling, as shipped request 14 at 265 s: $0.211 so farPolling, as shipped request 15 at 271 s: $0.248 so farPolling, as shipped request 16 at 278 s: $0.307 so farGets an event request 1 at 61 s: $0.015 so farGets an event request 2 at 66 s: $0.043 so farGets an event request 3 at 242 s: $0.059 so farGets an event request 4 at 248 s: $0.093 so farPolling, as shipped$0.31 · 20 requestseach step is one check(one or more requests)Gets an event$0.09 · 5 requestsa few requests, then onewake when the job endsCumulative cost of one wait, polling against eventsTwo lines: the median polling session climbs a step for every check; the median events session stays low until one wake at the end.$0.00$0.10$0.20$0.30$0.400200seconds of waitingjob donePolling request 1 at 1 s: $0.013 so farPolling request 2 at 4 s: $0.024 so farPolling request 3 at 6 s: $0.036 so farPolling request 4 at 9 s: $0.059 so farPolling request 5 at 39 s: $0.071 so farPolling request 6 at 41 s: $0.082 so farPolling request 7 at 43 s: $0.104 so farPolling request 8 at 105 s: $0.117 so farPolling request 9 at 108 s: $0.129 so farPolling request 10 at 110 s: $0.151 so farPolling request 11 at 230 s: $0.164 so farPolling request 12 at 232 s: $0.176 so farPolling request 13 at 234 s: $0.198 so farPolling request 14 at 265 s: $0.211 so farPolling request 15 at 271 s: $0.248 so farPolling request 16 at 278 s: $0.307 so farEvents request 1 at 61 s: $0.015 so farEvents request 2 at 66 s: $0.043 so farEvents request 3 at 242 s: $0.059 so farEvents request 4 at 248 s: $0.093 so farPolling$0.31 · 20 req.each step isone check (one ormore requests)Events$0.09 · 5 requestsa few requests,then one wakewhen the job ends

One four-minute crawl in Claude Code, polling as shipped against events, with jobs of matched length. Each step is one check of one or more requests to the model, at API list price.

Across the 14 combinations of server and agent in scope, events made the wait cheaper in 12, by half or more in 9. In Claude Code, waiting on a web crawl, a scrape or a video edit cost 71 to 76% less; on an API key, whose prompt cache lasts 5 minutes instead of an hour, the same three saved 36 to 57%. In Codex, which must poll on every server because it can't hold a call open past 300 seconds, savings ranged from 30 to 77%.

Percent cheaper per wait with events, by job server and harnessHorizontal bars: how much less a wait cost with events than with the server as shipped. Gray rows are outside the conclusion's scope.Claude CodeWeb scraping76%Web scraping, Claude Code 76% per wait ($0.331 → $0.080) 14.5 checks as shipped; n = 8 / 9; detectedVideo editing71%Video editing, Claude Code 71% per wait ($0.308 → $0.089) 23 checks as shipped; n = 8 / 10; detectedWeb crawling76%Web crawling, Claude Code 76% per wait ($0.318 → $0.078) 21 checks as shipped; n = 8 / 8; detectedAI model runnerExcluded*AI model runner, Claude Code outside the conclusion: the server holds the call and sends progress on jobs of about 5 minutes or less events -18% per wait (no detectable difference); every cell is in the appendixCI builds30% (not detected)CI builds, Claude Code 30% per wait ($0.139 → $0.097) 7 checks as shipped; n = 8 / 11; no detectable differenceSecond crawling APIevents cost 3% moreSecond crawling API, Claude Code -3% per wait ($0.094 → $0.096) 6 checks as shipped; n = 8 / 7; events cost moreAI video generationExcluded*AI video generation, Claude Code outside the conclusion: the server holds the call and sends progress on jobs of about 5 minutes or less events -27% per wait (events cost more); every cell is in the appendixResearch APIevents cost 14% moreResearch API, Claude Code -14% per wait ($0.179 → $0.204) 4.5 checks as shipped; n = 8 / 6; events cost moreCodexWeb scraping68%Web scraping, Codex 68% per wait ($0.140 → $0.045) 19 checks as shipped; n = 8 / 9; detectedVideo editing63%Video editing, Codex 63% per wait ($0.102 → $0.038) 17 checks as shipped; n = 8 / 10; detectedWeb crawling53%Web crawling, Codex 53% per wait ($0.078 → $0.036) 17 checks as shipped; n = 8 / 8; detectedAI model runner60%AI model runner, Codex 60% per wait ($0.115 → $0.046) 13 checks as shipped; n = 8 / 11; detectedCI builds59%CI builds, Codex 59% per wait ($0.088 → $0.036) 13 checks as shipped; n = 8 / 8; detectedSecond crawling API77%Second crawling API, Codex 77% per wait ($0.141 → $0.032) 22 checks as shipped; n = 7 / 7; detectedAI video generation30%AI video generation, Codex 30% per wait ($0.046 → $0.032) 11 checks as shipped; n = 8 / 12; detectedResearch API33%Research API, Codex 33% per wait ($0.114 → $0.076) 21 checks as shipped; n = 8 / 8; detected* Excluded: the server already held the call open and sent progress,on jobs of about 5 minutes or less. Every result is in the appendix.Percent cheaper per wait with events, by job server and harnessHorizontal bars: how much less a wait cost with events than with the server as shipped. Gray rows are outside the conclusion's scope.Claude CodeWeb scraping76%Web scraping, Claude Code 76% per wait ($0.331 → $0.080) 14.5 checks as shipped; n = 8 / 9; detectedVideo editing71%Video editing, Claude Code 71% per wait ($0.308 → $0.089) 23 checks as shipped; n = 8 / 10; detectedWeb crawling76%Web crawling, Claude Code 76% per wait ($0.318 → $0.078) 21 checks as shipped; n = 8 / 8; detectedAI model runnerExcluded*AI model runner, Claude Code outside the conclusion: the server holds the call and sends progress on jobs of about 5 minutes or less events -18% per wait (no detectable difference); every cell is in the appendixCI builds30% (not detected)CI builds, Claude Code 30% per wait ($0.139 → $0.097) 7 checks as shipped; n = 8 / 11; no detectable differenceSecond crawling APIevents cost 3% moreSecond crawling API, Claude Code -3% per wait ($0.094 → $0.096) 6 checks as shipped; n = 8 / 7; events cost moreAI video generationExcluded*AI video generation, Claude Code outside the conclusion: the server holds the call and sends progress on jobs of about 5 minutes or less events -27% per wait (events cost more); every cell is in the appendixResearch APIevents cost 14% moreResearch API, Claude Code -14% per wait ($0.179 → $0.204) 4.5 checks as shipped; n = 8 / 6; events cost moreCodexWeb scraping68%Web scraping, Codex 68% per wait ($0.140 → $0.045) 19 checks as shipped; n = 8 / 9; detectedVideo editing63%Video editing, Codex 63% per wait ($0.102 → $0.038) 17 checks as shipped; n = 8 / 10; detectedWeb crawling53%Web crawling, Codex 53% per wait ($0.078 → $0.036) 17 checks as shipped; n = 8 / 8; detectedAI model runner60%AI model runner, Codex 60% per wait ($0.115 → $0.046) 13 checks as shipped; n = 8 / 11; detectedCI builds59%CI builds, Codex 59% per wait ($0.088 → $0.036) 13 checks as shipped; n = 8 / 8; detectedSecond crawling API77%Second crawling API, Codex 77% per wait ($0.141 → $0.032) 22 checks as shipped; n = 7 / 7; detectedAI video generation30%AI video generation, Codex 30% per wait ($0.046 → $0.032) 11 checks as shipped; n = 8 / 12; detectedResearch API33%Research API, Codex 33% per wait ($0.114 → $0.076) 21 checks as shipped; n = 8 / 8; detected* Excluded: the server already held the callopen and sent progress, on jobs of about5 minutes or less. All results: appendix.

How much cheaper one wait was with events, per server and agent; 7 or 8 sessions as shipped and 6 to 12 with events per bar, medians at API list price. Faded bars are differences we couldn't detect. Jobs ran longer as shipped than with events for web scraping in Claude Code (562 s against 431 s) and the AI model runner in Codex (268 s against 134 s), which favors events there.

We found that tasks that reliably finish in under 5 minutes could interoperably be handled without events by letting the MCP server hold the request open and send progress until the work completes (see Alternatives below). Where a server already held the request open for a task like this, events delivered every result as well, at the same or higher cost (up to 27% more), so we excluded those results from the conclusion. They're in the appendix.

Alternatives

While events are an effective way to handle these types of activities, harness-specific alternatives do exist and can be as effective as events in some cases. One such alternative is to indefinitely hold calls open in Claude Code. If the server holds the tool call open and sends progress, Claude Code moves the call to the background and waits, for two hours in our tests, then reports the result as soon as the call returns. We found that, watching one inbox, it answered every customer reply within five minutes, at about the same cost as events. Holding the request has costs of its own: Claude Code is tied up for its first couple of minutes, and Codex narrates while it waits, which made a 5-minute hold cost about as much as polling. Beyond 5 minutes, Codex stops waiting, so it is not a viable strategy beyond Claude Code.

What this means

MCP Events are a natural fit for both long-running jobs and external events, making agents more reliable and efficient. But these benefits aren't realized today because agents largely don't support MCP Events and, consequently, servers rarely serve them. In the short term, Wakeshift acts as a bridge that allows MCP server developers to unlock events for connected agents. Ultimately, we see MCP Events as the correct solution and encourage agent developers and MCP server operators to adopt events to allow agents to become more reliable and efficient. And MCP servers integrated with the Wakeshift SDK serve MCP Events to agents that support them automatically.

While the absolute dollar differences were small on an hourly basis for events vs. the other techniques, for always-on agents at API pricing the cost can add up to more substantial sums. We estimate that for an always-on agent in Claude Code monitoring 3 external event servers, the incremental monthly cost of polling would be around $900. Multiplied by many such agents at an organization, it becomes a substantial line item for no added value over events.

Limits

We measured MCP Events through Wakeshift's bridge, not through native support in the agents, and in two agents: Claude Code on Opus 5.5 and Codex on GPT-6.1 Sol. Native support skips the bridge, so we expect it to match or beat these numbers. Each comparison rests on 6 to 12 sessions per approach for long-running jobs and 10 for external events.

For the external-events study, we excluded results that failed because of our own test setup, such as a fault in the test runner, and ran those sessions again, as the rules we registered in advance specified.

For the long-running jobs study, we excluded two Claude Code servers that already hold the call open and send progress on jobs under about five minutes, sessions affected by bugs we found and fixed during the study, and sessions that failed for unrelated reasons. The appendix describes every exclusion and its effect, and has every result we used.

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.