GitHub Copilot in Slack and Microsoft Teams arrived on August 21, 2026, as two changelog entries published within four minutes of each other, and both use the same status word: public preview. Mention @GitHub in a channel or a direct message and a Copilot cloud agent session starts. It can answer questions about your code, triage issues, investigate a failing build, make changes inside a secure cloud sandbox, and open a pull request that links back to the conversation.
Two details underneath the headline matter more than the headline. The first is money: the agent session draws on your Copilot entitlement, but the cloud sandbox it works in is metered on its own rates, per compute-second, per GiB-second of memory, and per GiB-month of snapshot storage, and those rates are published. The second is scope: GitHub’s own sources, published the same morning, do not agree on which Copilot plans can use the integration at all.
This post reads the primary sources directly, because no independent coverage of the launch had surfaced in search at the time of writing. Those sources are both changelog entries, both integration how-to pages, the sandbox billing page, and the ruleset documentation the how-tos point to. From them the post puts Slack and Teams side by side cell by cell, separates the two meters running on one session, and closes with the controls you actually have before a chat thread produces a pull request.
- 01Both surfaces are public preview, in GitHub’s own words.The Slack entry (09:07 PT) and the Teams entry (09:03 PT) each say “public preview” and each carry the subject-to-change disclaimer. Neither is general availability, and nothing in either entry gives a GA date.
- 02GitHub states eligibility three different ways.The Slack changelog names organizations on Copilot Business and Copilot Enterprise. The Teams changelog says paid GitHub Copilot plans. Both how-to pages say all paid Copilot plans. We do not pick one for you; check what your own plan unlocks.
- 03One session, two meters.The Teams changelog says sessions consume AI credits and that cloud sandbox usage is billed separately. The sandbox billing page prices compute at $0.000024 per compute-second, memory at $0.000003 per GiB-second, and storage at $0.005 per GiB-month, outside the Bundled AI credits budget type.
- 04Slack and Teams are not the same product.Slack gets a dedicated code channel per task (Slack Code) with archive-and-reopen; Teams has no documented equivalent. Teams needs the Microsoft Public Developer Preview toggled on in the client; Slack does not. Only the Teams entry spells out separate sandbox billing.
- 05The new JetBrains controls do not reach the chat surfaces.JetBrains got MCP allowlisting and a Bypass Approvals / Autopilot kill switch on August 18, three days earlier. Nothing in any GitHub source extends them to Slack or Teams. Your gates there are the org policy switch, repository write access, and rulesets.
01 — What ShippedTwo changelog entries, one status word, four minutes apart. #
The Teams entry, Shared agentic work with GitHub Copilot in Microsoft Teams, went live at 09:03 Pacific on Friday, August 21. The Slack entry, The new GitHub Copilot experience in Slack, followed at 09:07. Both describe the same core mechanic: an @GitHub mention in a channel, thread, or direct message starts a Copilot cloud agent session that can read the conversation, work in a cloud sandbox, and hand a pull request back to the thread. Both describe it with the same two words, “public preview,” and both add that the feature is subject to change.
That framing matters because Copilot has had a narrower Slack presence since March 2026, when GitHub documented creating issues from Slack. The August 21 entry describes something broader, a full cloud agent session that can investigate, change code, and open a pull request, and GitHub is treating that broader capability as preview software on both surfaces.
Copilot in Slack
Admin enables the Copilot cloud agent policy, the GitHub app for Slack is installed or upgraded, users link their GitHub account and mention @GitHub. Each task gets its own dedicated code channel, which can be archived and reopened later.
Copilot in Teams
Admin enables Copilot cloud agent and cloud sandboxes, which share one policy configuration, the GitHub app for Teams is installed, users mention @GitHub and connect their account. Public channels may need a default repository; direct messages skip that step.
write accessto the repository can trigger Copilot to make changes.
Read together with the August 19 releases from Cursor and OpenAI, which we covered in our piece on cloud agents that outlive the session, the pattern is hard to miss. Three vendors in three days moved the trigger for an agent out of the editor and into the places where work is discussed: a pull request thread, a GitLab issue, a Slack channel. GitHub’s version is the one most enterprises will meet first, because the Slack and Teams apps are already installed in their workspaces. That is exactly why the preview label, the eligibility wording, and the billing lines deserve a closer read than a changelog skim gives them.
02 — EligibilityFour GitHub pages, three wordings on who can use it. #
This is the finding most write-ups will miss, because it only surfaces when you read all of GitHub’s launch-day material rather than one page of it. The Slack changelog restricts the preview to organizations on Copilot Business and Copilot Enterprise. The Teams changelog, published the same morning, says only that the preview is available with paid GitHub Copilot plans, and names no tier. The two integration how-to pages on docs.github.com, one for Slack and one for Teams, carry an identical “Who can use this feature?” line: available for all paid Copilot plans. Their prerequisites sections ask only for a GitHub account with access to Copilot through a paid plan.
Slack changelog:“The public preview is available to organizations on GitHub Copilot Business and GitHub Copilot Enterprise plans.”
Teams changelog:“available with paid GitHub Copilot plans.”
Both how-to docs:“Available for all paid Copilot plans.” These are GitHub’s own words on the same day, and they are not
the same claim. We are not resolving it for you, because no GitHub source does. Check what your own plan exposes in the organization policy page before you tell a team of Pro-plan developers they can or cannot use this.
"The public preview is available to organizations on GitHub Copilot Business and GitHub Copilot Enterprise plans. Usage counts against your existing Copilot entitlements and can be managed with existing Copilot cloud agent budgets."— GitHub Changelog, The new GitHub Copilot experience in Slack, August 21, 2026
A reasonable reading is that the changelog’s narrower framing is the operative one for an enterprise buyer, since the enablement chain on both surfaces starts with an organization administrator turning on the Copilot cloud agent policy, and an individual Pro subscriber has no organization policy page to visit. But that is an inference about how the feature is wired, not a statement GitHub has made, and the docs’ broader language may reflect where the feature is heading rather than where the preview sits today. Treat eligibility as unsettled until your own admin can see the policy.
03 — Proprietary AnalysisSlack versus Teams, what GitHub actually wrote, cell by cell. #
At a glance the two integrations read as one feature on two surfaces. Reading both changelog entries and both how-to pages in full shows they differ in at least four places that affect a rollout: the eligibility wording, the billing sentence, a Slack-only channel mechanic, and a Teams-only client prerequisite. Every cell below traces to one of the four GitHub pages published or linked on August 21.
| Dimension | Slack | Microsoft Teams |
|---|---|---|
| Status and eligibility, as stated | ||
| Status word | “public preview,” subject to change | “public preview,” subject to change |
| Eligibility, changelog | Organizations on GitHub Copilot Business and GitHub Copilot Enterprise plans | “available with paid GitHub Copilot plans,” no tier named |
| Eligibility, how-to docs | “Available for all paid Copilot plans.” | “Available for all paid Copilot plans.” |
| Getting it running | ||
| Enablement chain | Org admin enables the Copilot cloud agent policy; install or upgrade the GitHub app for Slack; link your GitHub account; mention @GitHub | Admin enables Copilot cloud agent and cloud sandboxes (one shared policy configuration); install the GitHub app for Teams; mention @GitHub and connect your account; public channels may need a default repository |
| Extra client prerequisite | None documented | Microsoft Public Developer Preview must be enabled in the Teams client |
| Dedicated channel per task | Yes: a Slack Code channel per task to follow the plan, inspect diffs, and review previews such as HTML artifacts; archivable and reopenable | None documented; sessions run inline in the existing channel, thread, or DM |
| Money and merge control | ||
| Billing sentence, changelog | Usage “counts against your existing Copilot entitlements and can be managed with existing Copilot cloud agent budgets” | Sessions “consume AI credits”; “Cloud sandbox usage is billed separately and can be controlled with a product-level or SKU-level budget” |
| Who can trigger changes | Users with write access to the target repository; guest workspace members and outside collaborators cannot start or steer a session | Participants with write access to the repository; others can ask, add context, and steer |
| Approval rule for app-attributed PRs | Rulesets can require one additional approval for unattributed Copilot pull requests; on by default where a ruleset already requires at least one approval | Same ruleset, plus a Teams-specific rule: admins can require an extra approval for any PR attributed to the Microsoft Teams Copilot integration identity |
Two of those rows deserve a second look. The Slack Code channel is a real product difference, not a naming one: Slack sessions spin up a channel of their own where the team can watch the plan evolve and read diffs, then archive it with the task and reopen it later, while Teams sessions live in whichever thread they started in. And the Teams client prerequisite is a Microsoft-side gate on top of GitHub’s own org policy, which means a Teams rollout has two admin consoles in the critical path where a Slack rollout has one.
04 — BillingOne session, two meters: AI credits and the sandbox. #
The Teams changelog is the clearest statement of how a chat-triggered session is charged, and it is worth quoting in full: “GitHub Copilot cloud agent sessions started in Microsoft Teams consume AI credits. For organizations, cloud agent AI credit usage is governed by usage-based billing budgets. Cloud sandbox usage is billed separately and can be controlled with a product-level or SKU-level budget.” The Slack changelog never uses the words “billed separately” or “AI credits”; its only billing line is the entitlements sentence quoted in the previous section. That is an asymmetry in GitHub’s wording, not necessarily in the mechanism, and we attribute each sentence to the surface it appears on.
The mechanism itself is documented once, on GitHub’s billing page for cloud and local sandboxes, which the Teams changelog links directly and both how-to pages reach through their shared prerequisite that cloud sandboxes be enabled for your Copilot plan. Three meters run against a cloud sandbox, and GitHub publishes a rate for each.
Per compute-second
Charged for the time a session is running. Converted by us, not by GitHub, that is $0.0864 per compute-hour. GitHub publishes this meter per second, not per hour.
Per GiB-second allocated
Charged on memory allocated while the session runs. Our conversion: $0.0108 per GiB-hour. A sandbox’s default allocation is not stated on the billing page.
Per GiB-month of snapshots
Charged on snapshot storage for stopped sessions. Small per unit, but it accrues on every session a team stops and keeps rather than discards.
The table below puts the two meters on one page. The AI credits side is the mechanic we documented when GitHub replaced premium request units with token-metered AI Credits on June 1, where one credit is $0.01 and Business and Enterprise seats carry a pooled allowance. This post does not restate that audit; the new layer is the sandbox column, which that post could not cover because the chat surfaces did not exist yet.
| Line item | Billing unit | Published rate | Controlled by |
|---|---|---|---|
| Meter one: the agent session (AI credits) | |||
| Q&A, triage, issue creation, investigation, plan, PR | AI credits (1 credit = $0.01) | Token-metered; see the AI Credits playbook for plan allowances | Usage-based billing budgets for cloud agent AI credits (Teams wording); existing Copilot cloud agent budgets (Slack wording) | | Meter two: the cloud sandbox (raw USD, outside Bundled AI credits) | ||| | Sandbox compute | Compute-second | $0.000024 | Product-level budget (all sandbox usage) or SKU-level budget (e.g. Sandbox Linux), optionally “Stop usage when budget limit is reached” | | Sandbox memory | GiB-second | $0.000003 | Same product- or SKU-level budget | | Sandbox snapshot storage | GiB-month | $0.005 | Same product- or SKU-level budget | | Illustrative hour, our arithmetic from the rates above | ||| | One hour running with 4 GiB allocated (hypothetical) | 3,600 compute-s + 14,400 GiB-s | $0.0864 + $0.0432 = $0.1296, before any snapshot storage | Derived by Digital Applied; GitHub publishes no hourly figure, only the per-compute-second and per-GiB-second rates, and the billing page does not state a default memory allocation |
"Cloud sandboxes for GitHub Copilot are not part of the 'Bundled AI credits' budget type... To control cloud sandbox spending, use a product-level or SKU-level budget."— GitHub Docs, Billing for cloud and local sandboxes for GitHub Copilot
That sentence is the documentary proof that “billed separately” is a different line on the invoice and not a turn of phrase. Bundled AI credits budgets apply only to SKUs that consume AI credits, such as Copilot AI credits, cloud agent AI credits, and Spark AI credits. A team that set a Bundled AI credits budget after the June 1 change and believes it has capped Copilot spend has not capped the sandbox. The sandbox needs its own product-level or SKU-level budget, and if you want a hard stop rather than an alert, the “Stop usage when budget limit is reached” option has to be set on that budget specifically.
Two further details are easy to misread. Local sandboxing, which runs Copilot CLI on the developer’s own machine with OS-level isolation, is included in the standard Copilot seat at no extra cost; it is a different thing from the cloud sandbox that Slack and Teams sessions run in, and only the cloud sandbox bills. And the billing page’s account-attribution rule, where the repository owner is billed automatically when the work is inside a Git repository and you are otherwise prompted to choose an owner, is documented for the copilot --cloud
CLI flow. It is the general model for cloud sandbox billing, but we have not seen it stated word for word for the Slack and Teams trigger path, so confirm it on your first invoice rather than assuming it.
every sandbox secondis billed, and treat any credit that appears as a bonus.
Our read of the trend: GitHub is unbundling the compute an agent needs from the intelligence it applies, and pricing each on its own axis. Tokens are credits; runtime is seconds and gibibytes. That is the same direction the cloud providers took with serverless, and it is the right design for a product where a single @GitHub mention can set a machine running for as long as the task takes. Projecting forward, expect the per-second meters to become the cost line that grows fastest as teams let agents run longer, because the credit meter follows tokens while the sandbox meter follows wall-clock time. The budget that matters in six months is the one on the SKU, not the one on the credits.
05 — AttributionWhose name is on the pull request a thread produced. #
Both how-to pages draw the same line, and it is the line every reviewer needs to know. In a direct message, Copilot acts under the linked user’s own GitHub permissions. In a shared context, a channel or a thread, Copilot creates artifacts, including pull requests, under the Copilot app’s own identity rather than the person who asked. Because those pull requests are not attributed to a person, GitHub’s repository rulesets offer an additional approval for unattributed Copilot pull requests, one more than the existing minimum, and the docs say it is enabled by default wherever a ruleset already requires at least one approval.
Teams gets a named identity of its own on top of that. Repository admins can require an additional approval for any pull request attributed to the Microsoft Teams Copilot integration identity, and the Teams changelog gives the arithmetic: a repository that already requires two approvals will require three for a Teams-originated pull request. The four situations below are the ones to write a policy for.
One person, their own permissions
Copilot acts as the linked user. The PR carries a human name, the standard ruleset applies, and thread context is limited to the DM. The how-to docs point here for anyone who wants to limit what context the agent captures.
The app identity opens the PR
Artifacts are created under the Copilot app’s identity, not the requester’s. The unattributed-Copilot-PR rule adds one approval where a ruleset already requires one. Make sure that ruleset exists on every repo the app can reach.
A second, surface-specific gate
Admins can require an extra approval for PRs attributed to the Microsoft Teams Copilot integration identity. Two required approvals become three. Decide whether the stacking is protection or friction for each repo class.
Write access is the trigger
Only participants with write access to the target repository can trigger Copilot to make changes; others can add context and steer. In Slack, guest workspace members and outside collaborators cannot start or steer a session at all.
direct messageinstead. That is a training point for every workspace that turns this on, not a footnote.
06 — Governance ScopeJetBrains got four controls on Tuesday. The chat surfaces did not. #
Three days before the Slack and Teams entries, on August 18, GitHub published enterprise managed settings in GitHub Copilot for JetBrains. That entry carries no public preview disclaimer, unlike the two chat entries, which both state the feature is in public preview and subject to change. We read the absence as a release without a preview label; the word GA does not appear in the JetBrains text, so that is our inference and not GitHub’s status word. The four controls are server-enforced and specific.
Plugin governance
Enterprise administrators decide which plugins and which marketplaces the JetBrains Copilot agent can draw on.
MCP server allowlisting
Prevents connections to servers outside the enterprise allowlist. The same key names GitHub introduced for enterprise owners on August 6, now enforced in the JetBrains client.
Managed OpenTelemetry
Managed values take precedence over developer settings, so telemetry routing and what gets captured are decided centrally.
Permission-mode kill switch
Prevents the Copilot agent in JetBrains from using Bypass Approvals or Autopilot. The control most security teams asked for, and the one most worth wanting elsewhere.
allowedMcpServers
, deniedMcpServers
, or disableBypassPermissionsMode
govern a cloud agent session started from Slack or Teams. They are scoped to GitHub Copilot for JetBrains. The governance surface for chat-triggered sessions is the set in the previous section, app-identity attribution, ruleset-forced extra approval, write-access gating, plus the org-level Copilot cloud agent and cloud sandbox policies, which share one configuration and act as a single upstream on/off switch rather than a per-surface one. That is a thinnercontrol set than JetBrains got, and it is worth saying so before a security review assumes otherwise.
The contrast is instructive rather than damning. GitHub has been building fine-grained enterprise controls surface by surface: the managed-plugin and BYOK work in VS Code we covered in our enterprise-governed AI coding piece, then our write-up of the August 6 allowlist keys for enterprise owners, and now JetBrains. The chat surfaces shipped today and are in preview; it would be surprising if they had the same depth on day one. The practical consequence is that a team rolling out Slack or Teams this quarter governs it with coarse tools: a policy switch, a budget, and a ruleset. If your agent governance framework assumes per-setting controls exist for every agent surface, this is the surface where that assumption breaks.
07 — What To Do NowA rollout playbook for a preview with a meter attached. #
Everything below comes from GitHub’s own pages; the sequencing is ours. The aim is to turn the feature on for a bounded group with the money and the merge gates already in place, rather than discovering either from the first invoice or the first surprise pull request.
Settle eligibility with your own admin, not the changelog. Open the organization or enterprise policy page and look for Copilot cloud agent and Cloud Sandbox access. If the policies are there, you are eligible in practice whatever the wording says. If they are not, the narrower Business and Enterprise reading is the one to plan around.Create the sandbox budget before the policy switch. A product-level budget caps all cloud sandbox usage; a SKU-level budget caps one SKU such as Sandbox Linux. Set “Stop usage when budget limit is reached” if you want a hard ceiling. A Bundled AI credits budget does not cover this.Confirm rulesets on every reachable repository. The additional-approval rule for unattributed Copilot pull requests is on by default only where a ruleset already requires at least one approval. Repositories with no ruleset get no extra gate. For Teams, decide per repository class whether to stack the integration-identity rule as well.Enable the policy, then install the apps. Slack needs the Copilot cloud agent policy on and the GitHub app for Slack installed or upgraded. Teams needs Copilot cloud agent and cloud sandboxes enabled, the GitHub app for Teams installed, and Microsoft Public Developer Preview switched on in the Teams client. Public channels in Teams may prompt for a default repository.Brief the pilot group on the context rule. An @GitHub mention captures the whole thread and stores it in the artifacts. Sensitive work goes through a direct message. In Slack, explain that each task opens its own code channel and that archiving it is the close-out step.Read the first invoice line by line. Check that sandbox compute, memory, and storage appear as their own lines, that they landed on the account you expected, and whether any preview entitlement was applied. That is the moment to decide whether the budget you set is a ceiling or a tripwire.
Approval for app-identity PRs
One additional approval on top of the existing minimum, on by default where a ruleset already requires one. Teams can stack a second identity-specific rule, so two can become three.
Sandbox billing lines
Compute per second, memory per GiB-second, storage per GiB-month, all outside the Bundled AI credits budget type. Each needs a product- or SKU-level budget to cap.
Shared cloud agent + sandbox config
Cloud sandbox policies share the same configuration as Copilot cloud agent policies on both surfaces. One upstream switch, set by an org or enterprise owner, not a per-surface toggle.
For teams that would rather have this sequenced and tested by people who have done it on other agent surfaces, our AI transformation engagements start with exactly this kind of control-and-cost mapping before a pilot group touches the feature. If the question is less about policy and more about what to build once agents can be summoned from a thread, our web development practice runs these agents in production against real repositories and can show you the review workflow that survives contact with a 3am pull request.
08 — ConclusionA preview worth turning on, with the meter in view. #
The agent is on your entitlement. The machine it runs on is not.
GitHub Copilot in Slack and Microsoft Teams is a genuine step: the agent that used to live in an editor can now be summoned from the place a bug was first mentioned, work in a sandbox, and come back with a pull request. It is also, in GitHub’s own words on both surfaces, a public preview, with eligibility stated three ways across GitHub’s launch-day pages and a billing model that meters the session and the sandbox on different axes.
The honest summary of the money is a single sentence from the Teams changelog: sessions consume AI credits, and cloud sandbox usage is billed separately. The rates are published, the budget type that caps them is not the one most teams set in June, and the preview allowance the docs describe has a stated end date that passed before these surfaces shipped. None of that is a reason to wait. All of it is a reason to set the SKU-level budget first.
On governance, the gap is real and temporary in the way preview gaps usually are. JetBrains got MCP allowlisting and an Autopilot kill switch three days earlier; the chat surfaces get a policy switch, write-access gating, and a ruleset. Run the pilot inside those limits, insist on the extra approval for app-identity pull requests, and re-read the changelog when the preview label comes off. The wording will change. Whether your budget and your merge gates were in place first is the part you control.