Agents are part of how teams work in Slack — answering questions in threads, helping move tasks forward, and working alongside people in conversations. But what happens when the task is bigger than a question?
Agents can take on increasingly complex, multi-step work. Coding agents are a great example: they can investigate an issue, implement a change, work through iterations, share a preview, and incorporate feedback from teammates. The same is true when a research team asks an agent to gather and synthesize feedback, organize the findings, and work through the results together.
That kind of work needs room to evolve. The agent needs somewhere to make progress, share what it’s producing, bring people into the process, and keep the context from the original conversation. That’s where Slack Code comes in.
Slack Code gives your agent a dedicated channel for longer-running work, built on Slack’s existing channel model. Your agent can create a code channel from an existing conversation, carry that context forward, and give the agent and the people working with it a shared place to collaborate.
Instead of the agent working through a series of isolated responses, the work becomes a shared session where progress, decisions, artifacts, and collaboration all happen in one place.
Bring the work to the team
A Slack conversation is often where the work begins. Someone reports a bug. A teammate asks for help reviewing a change. A product discussion turns into an implementation task. Those conversations already contain valuable context, and Slack Code lets your agent carry that context into the work that follows.
With Slack Code, your agent creates a new code channel directly from an existing channel or thread, preserving the originating conversation and linking the new session back to it. That means people can move naturally between the original request and the work in progress without losing the story behind it.
Because Slack Code is built on Slack’s channel model, it also inherits the collaboration experience teams already rely on. Visibility, membership, notifications, approvals, and permission management all work within Slack, so you can focus on building your agent instead of recreating those collaboration patterns yourself.
For developers, that’s an important distinction: Slack Code isn’t a separate interface for agents. It’s a dedicated collaboration space built from the same primitives Slack already uses for teamwork.
Give people something to work with
When an agent is doing meaningful work, the final response is only part of the experience. People need visibility into what the agent is producing along the way — what changed, how the work is evolving, and how the agent is responding to feedback. Seeing that progress helps people build trust in the agent while giving them opportunities to guide the work toward the right outcome. Slack Code gives your agent several rich surfaces for sharing that work as the session progresses.
Your agent can publish:
- Code diffs, so teammates can review exactly what changed during the session.
- Block Kit views, giving you a flexible way to build interactive controls, structured data views, and custom experiences directly inside Slack.
- HTML previews, for showcasing generated interfaces and prototypes without leaving the conversation.
- Canvases, for longer-form content, documentation, research, and collaborative notes that evolve alongside the task.
Together, these surfaces make agent output something people can inspect and iterate on rather than simply read.
In a code channel you can also add visible links above the composer to resources associated with the session, such as a pull request, your development platform, or another external system. Keeping those resources connected to the session makes it easier for the work to continue even when the people involved change.
Make agent work multiplayer
One of the most interesting parts of Slack Code isn’t simply that agents have more room to work. It’s that the work becomes multiplayer.
A teammate doesn’t need to start a brand-new conversation with the agent, repeat the context, and wait for it to get back up to speed. They can join the existing code channel and immediately participate in the same session.
Imagine an agent generating a prototype for a new feature. A designer reviews the HTML preview and suggests a change. An engineer opens the code diff to inspect the implementation. A product manager adds context from a customer conversation. The agent incorporates that feedback and continues working. Everyone is collaborating around the same task, the same context, and the same artifacts.
This also creates opportunities for broader participation across a team. Someone without access to the underlying development environment can still review a prototype, comment on generated work, or help guide decisions, while the agent and authorized teammates handle actions that require additional credentials.
The result is a more collaborative workflow where agents contribute alongside the people building the product rather than operating in a separate conversation.
Let your agent manage the session
Slack Code is designed around the lifecycle of agent work. Your agent decides when a task deserves its own dedicated channel and creates the session when it’s needed. From there, the agent can stream progress, publish artifacts, update its status, share links to external resources, and eventually archive the channel once the work is complete.
While work is active, code channels appear in their own dedicated section of the sidebar, making it easier for people to keep track of multiple ongoing agent sessions across their workspace.
Status also becomes part of the collaboration experience. Users can see whether an agent is actively processing, waiting for input, or has completed its work, giving everyone a clearer picture of where the task stands without interrupting the conversation.
Together, these lifecycle primitives let your agent manage work from start to finish while keeping people informed and involved at the right moments.
Built on Slack’s channel model
Under the hood, Slack Code builds on concepts Slack developers already know.
The Slack Code APIs are currently in beta and available only to select partners. These APIs allow agents to create code channels from existing conversations, carry context into those sessions, and manage the lifecycle of longer-running agent work. The experience builds on familiar Slack events and OAuth scopes while introducing additional primitives designed specifically for Slack Code.
Slack Code introduces the code.channels:manage scope, which is included under the parent assistant:write scope. allowing agents to create and manage code channels as part of its agent experience.
For developers, that means you can build richer agent workflows using the same Slack platform foundations you already know instead of designing an entirely new collaboration model from scratch. We’re working toward making these capabilities more broadly available soon.
Build richer agent experiences
The shift with Slack Code is ultimately about expanding what an agent conversation can become.
Threads remain a natural place for questions, answers, and focused interactions. Slack Code extends that model when the work grows into something more collaborative — bringing together the original context, the agent’s progress, the artifacts it produces, and the people contributing along the way.
For developers building agents, that opens up new possibilities for creating experiences that feel less like isolated AI interactions and more like genuine team workflows happening inside Slack.
Your agent brings the capability. Slack Code gives it a collaborative place to do the work.
Availability & next steps
Slack Code is live today for teams using Claude (Anthropic), Devin (Cognition), GitHub (Copilot), and Vercel integrations, with OpenAI (ChatGPT) available soon. Mention the agent in a project channel to see it spin one up. Explore more at our help center or product page.
