Copilot Moves Into the Group Chat: @GitHub Goes Generally Available in Slack and Teams, with Canvas in Teams
GitHub made @GitHub generally available in Slack and Microsoft Teams on November 6: mention it in a chat and the Copilot cloud agent investigates bugs, creates issues, implements changes, and opens pull requests. Teams also gets Canvas, a review area beside the conversation. The real change is that review moves into the chat — and the bill for cloud sandbox usage is a separate matter.

Mention it in the group chat, and the coding task is on its way
On November 6, GitHub announced that @GitHub in Slack and Microsoft Teams is generally available. The way it works is simple: mention @GitHub in a group chat, say one sentence, and the Copilot cloud agent will investigate a bug, create an issue, implement a change, and open a pull request — all without leaving the conversation. On August 21 it was still a public preview; three months later, GitHub has taken the "preview" label off. This is not just a label change: Teams gains a review view called Canvas, the repository can be detected automatically, a bug that dropped replies to follow-up messages is fixed, and issues and pull requests created by the bot now say clearly which chat they came from.

First, what this is and is not. This is not Microsoft 365 Copilot, and it is not a question-answering bot dropped into Slack. Behind @GitHub is the same Copilot cloud agent that does the work on github.com, in the Copilot app, in the CLI, and in editors. It works asynchronously in a GitHub-hosted cloud sandbox and reports back when it is done, so you can go and do something else while it works. What changed is the entry point: sending work used to mean going to GitHub or an editor, and now one sentence in the group chat is enough. The entry changed; the worker did not.
For small teams, that matters more than it looks. Many bugs and requests first appear in the group chat: someone pastes a screenshot of an error in a channel, someone mentions in a meeting that a feature is broken. The old flow was to translate the chat into an issue first, then hand it to Copilot on GitHub — an extra layer of retelling, where the person retelling had to remember to paste links and write reproduction steps. Now that step is gone: mention @GitHub where the discussion already is, and the whole thread becomes the context, which the agent reads itself. Earlier decisions and error reports in the thread become the basis for its plan.
What general availability actually includes
GitHub's Changelog entry is short, but every line maps to a concrete change. First, @GitHub is generally available in Slack and Teams, and it does four things: investigate bugs, create issues, implement changes, and open pull requests. Note the order: investigate and create come before implement and open. The four jobs form a chain — first figure out what is wrong, then decide whether to file an issue, and only then change code and open a PR. The announcement does not promise it gets the change right the first time; it promises it can walk that chain inside the chat.
Second, Teams gets Canvas. Canvas is a review area attached to the conversation: implementation plans, code changes, and previews sit next to the chat, so the team can look, discuss, and refine without leaving. Reviewing a PR used to mean switching to GitHub; now the plan, the changes, and the discussion share one screen. This feature is Teams-only in this release — Slack does not get it. Teams that use different chat tools will now have different experiences: Teams users can review inside the chat, Slack users still have to switch out to look at the PR. GitHub has not said whether Canvas will come to Slack, or when. For now, the asymmetry is the reality.
Third, onboarding is faster. @GitHub now identifies the repository from your message and starts the session without requiring you to select it again. Getting started is also easier when you are not signed in, do not have a default repository, want to switch repositories, or need app access. That sounds like a small fix, but in daily use the difference is large: every task used to start with picking a repository, and picking wrong meant starting over. Now the repository is inferred from the message, so the first step of sending work has much less friction.
Fourth, two reliability fixes. One fixes an issue that could prevent responses to follow-up messages — before, a follow-up question could go unanswered and the work would stall halfway; now the conversation can continue. The other is attribution: issues and pull requests created by @GitHub now include "Created from a Slack/Teams conversation with @username" in their description — a note of which chat and whose message the work came from. That line is easy to underestimate: later, when someone finds a puzzling PR, they can follow it back to the chat and ask who asked for it. It does not explain the intent behind the request — a person still has to add that — but at least the origin is traceable.
Who can use it, and what it costs
The bar first: this is a feature for paid Copilot plans. GitHub's integration documentation lists Copilot integrations under paid plans, and the free tier is outside it. On the Slack side you install the GitHub app for Slack in your workspace, connect your GitHub account, and set a default repository; on the Teams side an administrator first allows the app in Teams policies and enables resource-specific consent so users can authorize conversation context, then each person connects their own account. The announcement itself lists no specific plans or prices, and gives no usage figures — which plans qualify and how quotas work live in the docs and billing pages, not in this Changelog entry.
The announcement also leaves the billing details unexpanded, with one loose end you need to check yourself: cloud sandbox usage is billed separately. According to GitHub's other Changelog entry from late October, billing for cloud sandbox usage starts in November 2026. In other words, mentioning @GitHub in the chat feels free, but the usage bill is a separate matter. Before a team adopts this properly, it should confirm three things: whether your Copilot plan includes the cloud agent, whether sandbox usage has a budget cap, and who watches that bill. Do not wait for the end-of-month invoice to discover that a few casual mentions in the chat all counted.
Permissions deserve a clear statement up front too. That anyone in the chat can mention @GitHub does not mean everyone in the chat can send work. The repository's existing rules still apply: who can approve and who can merge is decided by the repository. The agent changes code in a sandbox and opens a PR; whether it gets merged, and how, is still a human decision. GitHub's docs say the same: participants can follow the work and steer the plan, but repository permissions and existing approval rules determine who can authorize and merge changes. That sentence is the reassurance: the bot can act, but it cannot overrule.
A day of sending work from the group chat
Walk through the flow once and you can see what this actually saves. At 9:30 in the morning, someone pastes an error screenshot in a channel: the login page does nothing when clicked. The old way: someone takes it on, opens GitHub, files an issue, pastes the link, writes reproduction steps, then hands the issue to Copilot or fixes it themselves. The new way: the same person mentions @GitHub under that message and says "look into the login page not responding, find what is wrong". The agent reads the whole thread — including the context of the screenshot and someone's earlier note that the login logic changed last week — and starts investigating in a cloud sandbox.
When it finds something, it reports back in the chat: where the problem is, and how it plans to fix it. After the fix it opens a pull request, whose description reads "Created from a Slack/Teams conversation with @xxx", and you can open it to see which files changed. In Teams, Canvas opens beside the chat, with the plan, the changes, and the preview in view; someone reads it, thinks the change is too broad, and replies beside it, "leave the login logic alone, just fix the button", and the agent keeps working. Finally someone reviews the diff in Canvas, merges it, and says in the chat "merged" — the loop closes. Nobody opened the GitHub website in the process. That does not make GitHub unimportant; it means discussing, assigning, reviewing, and merging stayed in one place for the first time.
The most underestimated step in that flow is "reading the thread". Filing an issue used to require the filer to decide what mattered: the screenshot had to be pasted, the reproduction steps written, and who touched the related code last week might be forgotten. Now the agent reads the original thread and less context is lost. But that also raises a new bar: the discussion itself has to be written clearly. Vague descriptions, half a screenshot, or a bare "it broke again" leave the agent guessing. When sending work gets easy, how you report a problem matters more — state the symptom, the time, and the impact clearly. That is the basic skill of assigning work from the chat.
What to draw a line around: three things this is easily confused with
GitHub has shipped a dense run of Copilot updates over the past two months, and this one is easily confused with three others. Draw the lines once, here. First, the multi-repository Q&A from October 15: that update let Copilot answer questions across multiple repositories inside Slack and Teams chats. The focus was "asking" — answering questions, looking things up — not changing code. This general availability is about "doing": assigning work, changing code, opening PRs. A different thing. Second, the connected cloud experience GA from October 28: that was the Copilot cloud agent and cloud sandboxes themselves becoming generally available on paid plans, with Slack and Teams among the places you could use them. This time, two of those entry points — @GitHub in Slack and Teams — are being made generally available on their own, with Canvas added. Third, another Changelog entry from the same day, November 6: Copilot code review settings can now be managed through REST and GraphQL APIs. That is a management interface for review configuration, not assigning work from chat. Do not treat two November 6 entries as one event.
Drawing these lines is not just about accuracy; it sets the weight of this update. Copilot is moving from "an assistant inside the editor" to "a cloud colleague you can assign work to from anywhere", and Slack and Teams are two entry points on that road. The more entry points there are, the easier assigning gets — but the responsibility for review and permissions spreads wider too. That is why GitHub pushes Canvas hardest this time: once assigning is easy, review has to keep up, or PRs will pile up faster than anyone can review them.
What work fits in the chat, and what does not
When the bar is low, it matters more to know what can be casually assigned and what cannot. Work that fits in the chat has three traits: small in scope, clear in intent, and easy to verify. Fixing an error message, adding a line to an empty state, adding a test for a boundary case, changing an API timeout from 5 seconds to 10. The change is visible at a glance, verifying it means running it once and looking, and rolling it back is easy if it goes wrong. Send it with one sentence, get the PR back in half an hour, review it in five minutes, merge. The whole chain works.
Work that does not fit has three warning signs: it touches core logic, changes data structures, or spans several modules at once. "Add phone-plus-verification-code login", "split the orders table", "refactor the payments module". Jobs like that need the "what, who it affects, how to verify" to be thought through first, and one sentence in the chat cannot hold it. Forcing it through usually ends with the agent changing a large area on its own understanding, a PR with dozens of files that nobody can finish reviewing, and a round trip back to square one — worse than writing an issue and settling the plan first. One more category deserves special care: changes involving secrets, permissions, payment amounts, or user data. The cost of getting one of those wrong is high, and the risk-reward of a casual chat assignment is completely off. Those need the formal review flow, with at least two people having read the change before it merges.
A simple test: if you cannot say in one chat sentence "what to change, why, and how to tell it worked", the job does not belong in the chat. Write those three sentences into an issue first, and mention @GitHub once you have thought them through. Assigning work from chat saves switching costs, not thinking costs — the thinking step cannot be skipped.
What the team lead should line up before switching it on
If your team plans to adopt this properly, there are a few things for the administrator to do first. On Slack, install the GitHub app in the workspace, have members connect their GitHub accounts, and set a default repository. On Teams, the administrator first allows the GitHub app in Teams policies and enables resource-specific consent, then each member connects an account, grants organization and repository access, and picks a default repository. Either way, someone should walk through it once and write a one-page internal note: where to install it, which account to connect, what the default repository is, and who to ask when it breaks.
One more thing is easy to miss: the cloud agent policy for the organization is on by default, and an administrator who is not ready can turn it off and switch it on after the team has agreed its ground rules. The switch exists precisely because GitHub knows the risk: assigning is so easy that turning everything on before the team agrees its rules will make the PR list messy first. Try it small for a month: pick one channel and one kind of small job — fixing copy, adding tests, fixing small bugs — get it running smoothly, then open it up. During the trial, note three things: which jobs came back right the first time, which needed rework, and which should never have been sent from the chat. After a month, those notes are your team's own usage manual.
Slack users and Teams users do not get the same deal
This update is not even-handed across the two platforms. Teams gets Canvas; Slack does not. What Slack gets is faster onboarding, automatic repository detection, more reliable follow-up replies, and clearer attribution — all useful improvements, but no big-ticket item like "review in a different place". GitHub has not said whether Canvas will come to Slack, and has given no timeline. Teams on Slack that want Canvas have to weigh it themselves: switch to Teams for Canvas, or keep assigning in Slack and reviewing on GitHub.
One date is worth writing down: the legacy GitHub Teams app is to be renamed "GitHub (deprecated)" and retired on November 16, 2026, according to GitHub's plan. If your team still uses the old app, switch to the new one before November 16. Switching is not complicated, but the administrator has to allow the app and open the right authorizations first, and each member then connects their own account. Do not leave it to the last day — if authorization gets stuck, the chat route for assigning work goes down with it.
One sentence to sum up: @GitHub going generally available in Slack and Teams means Copilot's work-assignment entry point has formally moved into the group chat, and Teams gets a Canvas where you can talk and review side by side. Assigning is easier now, which makes review and permission responsibilities heavier. Agree first on what can be assigned in the chat, who reviews, and who watches the bill — then let the team mention @GitHub freely. Otherwise the few clicks you save will come back as a PR list nobody owns.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.