Copilot in Slack and Teams Is a Preview, and the Sandbox Bills

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

1. 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.
2. 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.
3. 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.
4. 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.
5. 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.
6. 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.

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.