jsonscraper
Markets
Back to journal

GitHub Event Streams wakes agents on pull request events instead of frequent polling

How event streams change communication between GitHub and local agents—and which events are available in preview

Editorial Policy Report an error

How can an agent know that a new review has been posted on a pull request without asking GitHub every minute or requiring the user to run a public server? On November 17, 2026, GitHub opened Event Streams in preview: a client subscribes to a pull request, keeps its connection to GitHub open, and receives events as they occur.

Article: GitHub Event Streams wakes agents on pull request events instead of frequent polling
Summary: On November 17, 2026, GitHub opened Event Streams in preview: agents can receive pull request events over a persistent connection, without polling GitHub on a schedule or running a public webhook server.
Image role: cover — the central idea
Section: 
Visual subject: Editorial photo illustration of a local software development workstation linked by a visible thin data stream to abstract pull reques
An event stream delivers pull request updates to a local agent without a public webhook server.© jsonscraper · AI-generated

The practical change is aimed at local agents and automations that need to react to repository updates. Without a webhook receiver of their own, the usual way to track changes is periodic API polling: frequent requests use up the rate limit, while infrequent ones delay reactions. An event stream lets processing start when a change is signaled, rather than checking on a timer.

Which events subscribers receive

The Event Streams documentation lists pull request events: a review being submitted, a new commit, a merge conflict, a pull request being merged or closed, as well as changes to the set of checks or the completion of an individual check. Events are delivered through Server-Sent Events (SSE); clients do not need a public webhook endpoint. This could suit, for example, an agent on a developer’s laptop that needs to react to a new review or commit.

An event signals that something has changed, after which the client retrieves the latest data through the GitHub REST API. For instance, a notification about a new review points to the associated API resource; the client can use it to fetch the current review or pull request state before taking the next action.

How a stream differs from polling and webhooks

Polling is straightforward: the client sends requests at a set interval and compares the responses. The interval sets a trade-off between latency and request frequency: with checks every minute, a reaction may have to wait for the next cycle, while more frequent checks can produce many requests that find no changes. GitHub cites this trade-off as a reason to use an event-driven alternative.

Article: GitHub Event Streams wakes agents on pull request events instead of frequent polling
Summary: On November 17, 2026, GitHub opened Event Streams in preview: agents can receive pull request events over a persistent connection, without polling GitHub on a schedule or running a public webhook server.
Image role: supporting illustration 2 — a different specific aspect
Section: How a stream differs from polling and webhooks
Visual subject: Infographic in Russian: three ways to receive pull
The diagram shows the connection direction and update delivery method for polling, webhooks, and Event Streams.© jsonscraper · AI-generated illustration

With Event Streams, the client creates a subscription to a pull request, connects to GitHub, and waits for events over the open connection. Webhooks also deliver events, but integrations typically need a publicly accessible endpoint to receive them. That makes a stream useful for an interactive client or local agent, while a webhook suits a service that already accepts incoming requests. Polling remains a simple option for infrequent checks where a fast reaction is not important.

One practical implication is that subscriptions are configured for a specific resource. GitHub’s documentation describes a subscription route for a single pull request, not a universal feed of every repository update. Design the handler around a particular pull request and the event types it needs.

How a local agent might work

Imagine an agent that helps review pull requests. When a review event arrives, the agent fetches the latest data and can prepare an analysis of the comments; after a new commit, it can rerun checks; after a pull request is closed or merged, it can finish the associated task. This is an example based on the GitHub event types listed, not a result of company-published testing of this scenario.

The sequence matters: an event reports that a change occurred, and the client then requests the current state from the indicated API resource. Because events may be repeated or arrive out of order, the handler should tolerate duplicate delivery and check the state through the API, rather than treating the notification order as a complete history of changes.

GitHub sends an event over an open connection; the local client then fetches the current pull request state and runs the appropriate handler.

Limitations to keep in mind

As of November 18, 2026, Event Streams is available in preview on all GitHub plans after a waitlist application is approved. Access is enabled for a specific account, so it does not automatically appear for every user. The documentation also notes that the feature is available on GitHub.com, but not yet on GHE.com.

A subscription covers one pull request and expires 24 hours after it is created. The stream does not replay events that occurred before the connection, during a brief interval after subscription creation, or while the connection is broken. GitHub recommends fetching the current pull request state once after subscribing and relying on API data when handling duplicates and out-of-order events. In practice, this means an agent needs reconnection handling and state reconciliation, not just an open connection.

The preview supports pull request events; the documentation describes the current set and notes that the API, event types, and limits may change. If an automation needs other repository events or guaranteed server-side delivery, check whether the stream covers them; otherwise, use a webhook or an API check.

For a local agent that needs to react to pull request events without a public server, Event Streams provides a direct event channel instead of frequent requests. The trade-off is a temporary subscription to a single pull request and the need to restore the current state after missed events. Infrequent checks are better suited to polling, while server integrations can use webhooks when they need delivery to their own endpoint.

People

No people listed for this article yet.

Keep readingGitHub Connects Copilot to Cloud Sandboxes and a Shared Actions Compute Allowance
Read the next article

Turn what you read into a working integration

Explore jsonscraper's social-data APIs, test requests and build your next workflow.

Explore APIs