I built a tiny TypeScript server to figure out how ChatGPT can react to things happening outside the conversation.
One of the things from OpenAI DevDay 2026 that caught my attention was MCP Events.
Most MCP integrations I’ve built or seen work in one direction. You say something to ChatGPT, it decides to call a tool, your MCP server does something, and the result comes back.
Events add the other direction. Your app can have something happen while nobody is talking to ChatGPT, and ChatGPT can already be subscribed to hear about it.
That sounded simple enough, but I wanted to actually build the flow instead of only reading the spec. So I made mcp-events-starter, a deliberately small TypeScript implementation of MCP Events.
What I built
I used a task board because I didn’t want the example application itself to be interesting.
There is one event: task.created.
A client can subscribe to that event, optionally for a specific project. When somebody creates a matching task, the MCP server sends the event to the subscriber.
So the basic flow is:
Subscribe → create a task → receive the event.
There is also an unsubscribe method because I wanted the repo to show the whole lifecycle rather than stop at the nice demo part.
The server supports MCP protocol version 2026-07-28, which ChatGPT MCP Events requires. It implements discovery, event listing, subscription and unsubscribe alongside a normal create_task tool.
The useful part for me was seeing both models next to each other. create_task is normal MCP: ChatGPT asks my server to do something. task.created is the reverse: something happens in my app and the server tells the subscriber about it.
The webhook was the part that took more work
The task board itself is basically nothing. The webhook flow was more interesting.
When somebody subscribes, the server doesn’t immediately trust the callback URL and start sending task data to it. It first sends a signed challenge. The receiver has to respond correctly before the subscription starts receiving events.
Actual deliveries are signed too, using Standard Webhooks signatures.
There were a few implementation details here that I initially missed. For example, the signature has to be calculated over the exact JSON bytes that are actually sent. The server also validates callback addresses before connecting to them instead of accepting an arbitrary URL and blindly POSTing to it.
I added a tiny local receiver to the repo as well, so you can see all of this happen without needing ChatGPT involved yet. Run the server in one terminal, the receiver in another, subscribe, create a task, and you’ll see the signed event arrive. That made the whole thing much easier to understand than just reading through the protocol.
One catch: authentication
There is one limitation in the starter worth pointing out. The local version uses a shared bearer token. That keeps the repo small and works well for testing with curl or another client where you control the headers.
It does not mean you can put the server behind an ngrok tunnel and immediately connect it as a live ChatGPT plugin.
ChatGPT can’t be configured to send an arbitrary API key to your MCP server. For a real ChatGPT connection, you need the authentication flow OpenAI documents for plugins, which means adding OAuth. I left that out intentionally.
I wanted this repo to answer one question: how do MCP Events actually work?
Adding OAuth, a real database, durable delivery queues and everything else you’d want for production would make it a better application, but a much worse starter.
Why I wanted to try this
I think Events become particularly useful once your MCP server is connected to something that changes without the user explicitly asking for it. A task gets assigned. A build finishes. A document gets a new review comment. A background process completes.
With tools alone, ChatGPT has to ask your application for information. With Events, it can subscribe first and your application can tell it when something changes.
OpenAI’s own MCP Events documentation uses examples like watching for new feedback or document comments. That was the bit I wanted to get working. The starter is here:
github.com/rohanprichard/mcp-events-starter
If you’re looking through the OpenAI DevDay 2026 announcements and want to experiment with MCP Events, clone it and run the local loop. Once you actually see a task turn into a signed webhook event, the feature makes a lot more sense.
And if the starter saves you some time or effort, a star on the repo would be appreciated.