GitHub Event Streams Is Now in Public Preview

GitHub's new Event Streams preview lets agents and automation receive pull request updates over an open connection instead of polling the API.

GitHub's generic blog graphic used on its changelog post announcing the Event Streams public preview
GitHub's changelog social card for the Event Streams preview announcement. Image: GitHub.

GitHub Event Streams is now in public preview. It lets an agent or script subscribe to a single pull request and hold an open connection to GitHub, so GitHub pushes updates — a review landing, new commits, a merge conflict, a check suite finishing, the pull request closing — the moment they happen, instead of the agent calling the API over and over to check. GitHub announced the preview on November 17, 2026, and framed it squarely around AI coding agents: the pitch is that an agent "sleeps while there's no work and wakes as soon as there is," without anyone building or tuning a polling loop.

What is GitHub Event Streams?

Event Streams is GitHub's new real-time layer for pull request activity, announced in a GitHub changelog post on November 17, 2026. Under the hood it's an "Event Subscriptions" API: a client creates a subscription against one pull request and a set of event types, then opens a Server-Sent Events (SSE) connection to receive them as they occur. GitHub describes the goal plainly in its changelog: turn GitHub into "a real-time coordination layer between developers, agents, and automation," rather than a system other programs have to keep knocking on.

The feature currently covers pull requests only — not issues, not repositories generally — and it's available only on GitHub.com (not GitHub Enterprise Server or GHE.com) for accounts that have been approved off a waitlist. GitHub has not said whether it plans to extend the same model to other resource types once the preview matures, though the architecture (subscribe to one resource, stream its events) would generalize fairly naturally to issues, discussions, or repositories if GitHub chooses to go that direction later.

The polling problem it solves

Before Event Streams, an agent or CI script that needed to react to pull request changes had exactly one option without standing up a webhook receiver: poll. GitHub's own changelog lays out the trade-off agents have been stuck with:

The polling dilemma, in GitHub's words

  • Poll often, and you burn rate-limit budget on requests that mostly come back with nothing new.
  • Poll less often, and feedback — a failed check, a requested change — sits unseen until the next check-in.

That trade-off matters more now that AI coding agents routinely open pull requests, wait on CI, and respond to review comments on their own. Each of those agents previously had to either hammer the REST API on a timer or run a webhook listener with a public endpoint — infrastructure that's awkward for something running on a developer's own laptop. Event Streams removes both problems at once: no public endpoint, and no polling loop to tune.

How Event Streams works

The flow, per GitHub's Event Streams documentation, is a short sequence:

  1. Create a subscription for one pull request and the event types you care about, via POST /event-subscriptions.
  2. Open the subscription's event stream (GET /event-subscriptions/{id}/events) over HTTPS using Server-Sent Events, and keep it open.
  3. Receive an event on the stream each time something you subscribed to happens.

Authentication uses ordinary user tokens (personal access token, OAuth token, or GitHub App user access token) or GitHub App installation tokens — not apps authenticating purely as themselves. The connecting token also needs read access to the pull request in question. While the stream is idle, GitHub sends SSE heartbeat comments at least every 15 seconds so clients can detect a dead connection; there's no event replay, so anything that happened before the stream opened, or during a disconnect, has to be caught up separately by re-fetching the pull request.

Each subscription is scoped to a single pull request, lasts 24 hours, and a token can hold up to 100 active subscriptions before GitHub starts rejecting new ones with a 422. Subscriptions aren't automatically torn down when a process exits, either — cleanup is the client's job, and GitHub's docs note that deleting a subscription doesn't close any stream that's already open against it, so a well-behaved client closes the stream first and deletes the subscription second.

Picture a simple agent loop built on this: the agent opens a pull request, creates a subscription for review and check-suite events, and then does nothing until the stream delivers something. A check suite finishes with a failing conclusion, and the agent wakes up, fetches the failure details from the event's api_url, and starts fixing it. A reviewer approves the change, another event arrives, and the agent (or a human) merges. No step in that loop involves the agent asking "is anything new yet?" on a timer — it simply waits on the open connection until GitHub has something to say.

What events you can subscribe to

GitHub's changelog lists the events in plain language; its documentation gives them formal CloudEvents-style type names. Both are useful, so here's the full reference:

Event typeFires when…Notes
com.github.pull_request.review.submitted.v1A review is approved, requests changes, or is submitted as a commentEach review comment and reply also counts as a review event
com.github.pull_request.head.changed.v1New commits are pushed to the pull request's head—
com.github.pull_request.merge_conflict.v1GitHub detects a merge conflictCan be delayed; GitHub only checks for conflicts after someone views or requests the pull request
com.github.pull_request.state.changed.v1The pull request is merged, closed, reopened, marked ready, or converted to draft—
com.github.pull_request.check_suite.status.changed.v1A check suite on the head commit completesOne event per check suite — a single push can trigger several, one per app, and re-runs generate more

There's a deliberate gap worth knowing about: there is no single "all checks completed" event. An agent that needs to know when every check suite has finished has to track each check-suite event itself and compare against the pull request's current check suites. Ordinary comments on a pull request's Conversation tab also don't generate events — only review comments do.

Events don't carry full payloads, either. Each one tells you something changed and gives you an api_url to fetch the current state — useful as a deduplication key too, since GitHub's docs are explicit that duplicate and out-of-order delivery are both possible on the stream.

The API, and the gh CLI

Developers who want to work with Event Streams directly hit a small REST surface under api.github.com: creating, listing, fetching, and deleting subscriptions, plus the events endpoint itself. But most people won't need to write that by hand. A day after the Event Streams preview shipped, GitHub added CLI support: GitHub CLI 2.105.0 introduced gh event listen, which creates the subscription, opens the stream, and prints each event as JSON — by default exiting after the first one, which makes it drop neatly into scripts and agent loops. Flags let you wait for several events (--count), keep listening indefinitely (--follow), cap how long you wait (--timeout), or pull out just the fields you need (--jq / --template). A companion gh event subscription command handles creating, listing, viewing, and deleting subscriptions directly, and GitHub says gh pr create, gh pr view, gh run view, gh run watch, and gh api now actively suggest gh event listen in place of polling.

Both the API and the gh event commands are explicitly in preview, and GitHub warns it may make breaking changes to the API, event types, and limits on short notice.

How to get access

Event Streams is gated behind a waitlist rather than a flag anyone can flip on. Signing up happens at gh.io/event-streams-signup, and access is granted per account once approved. A few access details matter for teams:

  • For personal tokens, your own user account needs to be enabled.
  • For GitHub App installation tokens, the installing user, organization, or enterprise needs to be enabled — which covers every app installed there, including the automatic GITHUB_TOKEN inside GitHub Actions, but not individual members' own personal tokens.
  • Requests from accounts that haven't been approved come back as a flat 403.

GitHub says the preview is available on every GitHub plan once an account clears the waitlist, and as of launch it hasn't published any pricing for the feature.

Limits and known gaps

A few constraints are worth planning around before building on this in preview:

ConstraintDetail
ScopePull requests only, on GitHub.com (not GHE.com or GitHub Enterprise Server)
Subscription lifetime24 hours per subscription; a new one is needed to keep receiving events
Subscription cap100 active subscriptions per user, app, or installation token
ReplayNone — only events that occur while the stream is open are delivered
Ordering/duplicatesPossible; GitHub recommends treating each event's api_url as a dedup key
Installation tokensExpire after one hour; a fresh token is needed before reconnecting
GITHUB_TOKEN in ActionsCan't be renewed, and its subscriptions should be deleted before the job ends

GitHub is collecting feedback on all of this in a GitHub Community discussion rather than treating the preview design as final.

Why it matters for AI coding agents

The framing GitHub chose — an agent that "sleeps while there's no work and wakes as soon as there is" — is aimed squarely at the current wave of autonomous and semi-autonomous coding agents, the kind that open a pull request, wait for CI, and act on review feedback without a human driving each step. Tools like GitHub Copilot's coding-agent mode and editor integrations such as VS Code's agent and chat features already operate this way; Event Streams gives anyone building similar automation a supported way to find out when a pull request needs attention, rather than reinventing a polling loop or standing up webhook infrastructure just to watch one pull request. For agents running outside a data center — on a contributor's own laptop, say — the lack of a public endpoint requirement is the practical unlock: there's nothing to expose to the internet and nothing for a firewall or NAT to get in the way of.

It's also a narrower, more disposable alternative to webhooks for this one use case. Classic GitHub webhooks are push-based too, but they require a durable, publicly reachable receiver and are typically set up once per repository or organization for every event type at once. If you're comparing the architectural trade-offs between a push model like this and more traditional request-routing infrastructure, our explainer on API gateways versus load balancers covers the broader territory of how systems route and manage that kind of traffic.

What's next

GitHub hasn't published a roadmap or a general-availability date for Event Streams, and it has explicitly reserved the right to change the API, event types, and limits while the feature is in preview. The most concrete signal so far is the pace of the rollout itself: the preview shipped November 17, 2026, and GitHub CLI support for it followed within a day, suggesting GitHub is actively building out the surrounding tooling rather than treating this as a one-off API drop. Expect the event catalog to grow beyond pull requests if the preview goes well — issues and repository-level events are the obvious next candidates given how GitHub already models activity elsewhere in its API — though GitHub has not confirmed any specific expansion. For now, developers interested in building agents or automation on top of it can join the waitlist and start testing against the current API before any of that is locked in.

Frequently asked questions

What is GitHub Event Streams?

GitHub Event Streams is a public preview feature that lets an agent or automation subscribe to a pull request and receive updates - reviews, new commits, merge conflicts, merges, check suite status changes - over an open connection, instead of repeatedly calling GitHub's API to check for changes.

How is Event Streams different from GitHub webhooks?

Both are push-based, but webhooks require a durable, publicly reachable endpoint and are usually configured per repository or organization. Event Streams needs no public endpoint - a client opens an outbound Server-Sent Events connection to GitHub, so it can run on a laptop, and each subscription covers one pull request for 24 hours.

How do I get access to GitHub Event Streams?

Access is gated behind a waitlist. Sign up at gh.io/event-streams-signup; once your account (or, for GitHub Apps, your organization's installation) is approved, Event Streams is available in preview on every GitHub plan at no published extra cost.

What events can I subscribe to with Event Streams?

Five event types covering pull requests: a review submitted, new commits pushed (head changed), a merge conflict detected, the pull request's state changing (merged, closed, reopened, etc.), and a check suite's status changing, with one event fired per check suite.

Does GitHub Event Streams cost extra?

GitHub has not published any pricing for Event Streams. It says the preview is available on all GitHub plans once an account is approved from the waitlist.

Can I use GitHub Event Streams with the GitHub CLI?

Yes. GitHub CLI 2.105.0 added gh event listen, which creates a subscription, opens the stream, and prints events as JSON, plus gh event subscription commands for managing subscriptions directly - both still in preview.

Sources

More on GitHub Event Streams →GitHubEvent StreamsAI coding agentsGitHub APIDeveloper tools
Felix Moreau
Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Software & Guides

See all