GitHub shipped a public preview of Copilot agent session streaming — prompts, responses, and tool calls — into SIEM or Purview, plus a REST API that returns the last 48 hours: auditability for the coding agent became a platform feature.
Imagine hiring a brilliant employee who works tirelessly, writes code at superhuman speed, and touches dozens of internal systems, but of whom you keep not a single record of what they did, what they read, or what command they ran. Until recently, that's exactly what it was like to let an AI agent write code inside your company: it came in, acted, and left without a trace. On July 2, 2026, GitHub closed part of that gap by launching a public preview of Copilot agent session streaming, which opens access to the agent's session data — prompts, responses, and tool calls — for GitHub Enterprise Cloud customers with enterprise managed users. The agent stopped being a black box that spits out pull requests: now it leaves a trail.
The black box finally talks
What matters isn't that Copilot writes code — it already did that — but that it now exposes what it decides. The coding agent doesn't just autocomplete lines: it takes instructions in natural language, reasons, and calls tools — reading files, running commands, querying APIs. Every one of those actions is a decision that used to vanish. GitHub now captures all three layers: the prompt (what you asked it, or what it asked itself), the response (what it generated), and the tool calls (what it touched in the real world). It's the difference between knowing an employee 'worked on the project' and having the video of every key they pressed.
Two doors: the firehose and the bucket
GitHub offers two ways to pull that data out, and the choice reveals how companies think about governance. The first is a streaming endpoint: you configure a destination — an event collector, your SIEM (Splunk, Sentinel, whatever you use), or Microsoft Purview, which is also arriving in public preview — and the data flows on its own, in near real time, like an open firehose into your security center. The second is an on-demand REST API: GET /enterprises/{enterprise}/copilot/usage-records, which returns the last 48 hours of session data when requested. Firehose for continuous monitoring, bucket for point-in-time audits. The scope covers cloud agents on github.com and ghe.com, and sessions from Copilot CLI, VS Code, Visual Studio, and partner IDEs from JetBrains and Eclipse.
Why this weighs more than a logging feature
Here's the twist that matters: agent observability is turning into a platform capability, not a luxury. When an AI with write permissions touches your repos, your secrets, and your production systems, the security team's question isn't 'is it useful?' but 'can I audit what it did when something goes wrong?'. Without that record, the agent is a compliance risk no CISO will sign off on. With it, every action is reconstructable, attributable, and reviewable — the three verbs that separate a toy from a tool fit to operate inside a regulated enterprise. GitHub isn't selling speed here; it's selling the trust that makes the speed approvable. And that's the quiet play of 2026: agent governance became the real unlocker of adoption.
The lesson for anyone building with AI
The takeaway is clean: if you're going to let an agent act on your behalf, a structured record of what it did isn't optional — it's what makes the operation defensible. It isn't enough for the AI to be good; it has to be auditable, or sooner or later someone asks 'what exactly happened here?' and you have no answer. At NeuralOS we start from that same conviction: structured logging and an append-only audit log are core standard, not a later patch — every action with its ID, its context, and its traceability, never an empty catch that swallows the error. We're not promising an enterprise SIEM dashboard like GitHub's today; we are building on the principle that makes it possible: an agent you trust is an agent whose steps you can reconstruct. The black box was the previous era. The one coming is written, line by line, in a record someone can read.