@GitHub in Slack and Teams review: good at turning a thread into a pull request, so mind what the thread says
Anyone who has watched a bug report die in a Slack thread will like this one. Mention @GitHub and Copilot reads the whole conversation, opens a coding session and comes back with a pull request. The catch is in that first part: the whole conversation.

Worth turning on for engineering teams that already discuss bugs in Slack or Teams and already require pull request review. Generally available since November 6, 2026 on paid Copilot plans, @GitHub reads the entire thread as context, opens issues and pull requests, and in shared channels acts under its app identity, which adds a required approval when your rulesets already demand one. Keep it to a few channels with set default repositories, and keep secrets and customer data out of those threads.
What it does now
On November 6, GitHub made @GitHub in Slack and Microsoft Teams generally available. Mention it in a thread or send it a direct message, and Copilot's cloud agent can investigate a bug, create issues, implement a change and open a pull request without anyone leaving the conversation.
The release added a few practical things. In Teams, a Canvas shows the implementation plan, code changes and previews next to the discussion. Onboarding is faster: @GitHub works out the repository from your message instead of asking you to pick it again. And issues and pull requests it creates now say "Created from a Slack/Teams conversation with @username" in their description, so whoever reviews the work can trace where the request came from.
GitHub's docs fill in how it works. When you ask for a task in Slack, the agent opens a dedicated code channel, called Slack Code, one channel per task, where you and teammates steer the session. The work itself runs asynchronously in a cloud sandbox, and the result is posted back when it's ready. A session can span up to 11 repositories owned by the same organization or account. You can pick the model per conversation, MCP servers configured on a repository are available when it works there, and Copilot Memory, still in public preview, can carry repository facts and preferences between sessions.
Who it is for
Teams that already talk about bugs in Slack or Teams and already have real pull request review. If a support lead posts a broken checkout screenshot, two engineers discuss it, and someone eventually opens a ticket, this tool shortens that path to minutes.
It's available on all paid Copilot plans. If you get Copilot through an organization or enterprise, the "Copilot in the cloud" policy is on by default and an owner can turn it off. For enterprise-owned repositories, admins install the Slack app and choose which repositories it can reach.
It's a weaker fit for teams where code review is a formality, and for companies whose chat channels routinely carry credentials, customer records or legal discussion.
Decision guide
Who Copilot is when you ask it
| Consideration | Direct message | Shared thread or channel |
|---|---|---|
| Identity | Acts with your linked GitHub account's permissions | Creates pull requests and issues under the app identity |
| Context | Only what you send it | The entire thread, stored in the artifacts it creates |
| Merge rules | Your normal review requirements | One extra approval when rulesets already require at least one |
| Default repository | None; name repos in the prompt | Channel defaults, shared by everyone in the channel |
In a shared channel, the thread is the spec. Everything anyone typed in it is now a requirement.
Where it is strong
It respects GitHub permissions. Only people with write access to every repository selected for a session can trigger changes or steer it. Anyone in the thread can add input, but guests and outside collaborators can't start or steer a session. Creating issues needs the permission you already have.
Attribution is honest. In a direct message, the agent acts with your linked personal permissions. In a shared thread or channel, pull requests are created under the app's identity, not yours. Because that pull request isn't attributed to a person, repositories with rulesets that already require at least one approval will require one more before merging. That's on by default, and it's the right default.
It turns talk into a reviewable artifact. A pull request that cites the conversation it came from is easier to review than a fix someone half-remembers from a call.
Where it falls short, or needs your discipline
The whole thread is context. GitHub is clear about this: when you mention @GitHub in a thread, the agent captures the entire thread and that context is stored in the artifacts it generates. A pasted log with a token in it, a customer's address, a half-joking "just delete the old table" — all of it informs the work and may end up in an issue description.
In a shared channel, the thread is the spec. Everything anyone typed in it is now a requirement.
If you want to limit the context, GitHub's own advice is to send a direct message instead.
Channel settings are shared. Default repositories and the default model are set per channel and apply to everyone in it. One person changing the defaults changes them for the whole team. Pick an owner per channel.
It's one more front door. Requests can now arrive from chat as well as from issues and the IDE. That's useful, and it means your triage process should know about it, or work starts that nobody prioritized.
MCP servers widen the reach. Any MCP server configured on a repository is available to the agent when it works there. GitHub notes that a repository administrator sets the servers, the allowed tools and the credentials, and suggests reviewing tools and data access before enabling one. A thread in Slack can now indirectly reach whatever those servers can reach, so the list deserves a second look.
Memory is a preview. Copilot Memory stores repository facts and personal preferences between sessions. For organization plans an admin has to enable it first. That's sensible, and it means one more setting to decide on deliberately rather than by default.
Pricing depends on your Copilot plan. There's no separate price for the Slack or Teams integration in the announcement; usage runs under your paid Copilot plan, so check how cloud agent sessions count against it before you open it to the whole company.
Sequence of work
A sensible first two weeks
- Day 1
Install for one workspace. Pick two channels and set their default repositories.
- Day 2
Write a short channel note: no secrets, no customer data, DMs for anything sensitive.
- Week 1
Use it for investigations and issue creation only. Read what it files.
- Week 2
Allow pull requests. Keep branch protection and required review exactly as they were.
Plain verdict
Turn it on, carefully. For engineering teams with real review, @GitHub in Slack and Teams is a genuine improvement on copying a thread into a ticket. Start with two channels, set their default repositories, write a one-line rule that secrets and customer data stay out, and leave branch protection exactly as strict as it was.
Compared with assigning Copilot's cloud agent from a GitHub issue, this is the same agent with a friendlier front door and a noisier input. Compared with GitHub Agentic Workflows, which run repo chores on a schedule, this one starts from people talking. If your team's chat is messy, fix that first.
What to tell the team on day one fits in four lines. Mention @GitHub in the channel for work everyone should see. Use a direct message for anything with sensitive detail. Read the pull request like any other, because it is one. And if a thread turned into an argument, start a fresh thread before you ask the agent to act on it.
If you want help deciding where agents should be allowed to start work and who reviews what they produce, that is our AI applications and agents practice. Talk to TWIMCO.
Related work: Spin:Market
We build alongside the people doing the work.
Bring us the problem you’re thinking about.