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.
Reliability: With events, agents acted on 100% of external events within five minutes, and no user had to prompt the agent for a job's result. Without events, basic polling approaches in Codex could miss 49 to 82% of events. Users had to ask the agent for updates in 21% of job results, and 16% saw no updates at all.
Token cost: Compared with polling, events cut the idle token cost of waiting for external events by about 90% in the typical case, and cut the token cost of waiting on a job by 30 to 77% in most cases.
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.
Scroll sideways to see the whole table.
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.
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.
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.
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%.
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.