Hands Off Development

Triggering Coding Agents From Slack

Slack Code turns a team thread into a reviewable agent run.

· 8 min read · Updated
Cover illustration for “Triggering Coding Agents From Slack”
Coding Agent Integrations · October 24, 2026 · 8 min read · 1,881 words

Triggering coding agents from Slack moves delegation, context, and approval into the team’s communication layer. Slack Code lets teams tag an agent in a conversation and inspect its work in a dedicated code channel. A maintainable workflow depends on preserving that context through an isolated execution environment and back to a reviewable result, with human approval and attribution intact.

Why triggering a coding agent from Slack is a workflow shift, not a chat shortcut

In a private terminal, one engineer works with one agent, and the rest of the team sees the result when a pull request appears. The work becomes public only at the end. The bug report, the discussion that narrowed the problem, and the decisions behind the implementation can remain detached from that result. Moving the trigger into Slack changes who can initiate, observe, and approve the task because those activities now share a team-visible surface.

The thread with a feature request or bug report gives the agent its brief, and the team can discuss the plan and proposed changes. Anthropic’s December 8, 2025 research preview introduced delegation to Claude Code from Slack threads. Slack Code launched August 20, 2026 on every Slack plan, giving teams a shipped product for working together this way.

How Slack built the infrastructure that makes agent triggers possible

Slack’s MCP server and Real-time Search API, released February 17, 2026, gave third-party agents governed access to workspace channels, messages, and files. That supplied the data layer for reading task context. The Slackbot MCP Client then provided tool discovery and invocation, letting Slackbot connect to external MCP servers and use their tools during a conversation. Salesforce made the client generally available in June 2026, connecting Slackbot to more than 20 partner applications. These layers served different purposes but depended on each other. Slack Code added the governed collaboration surface above them, where agent-written code could be reviewed, approved, and logged.

What actually happens when a Slack message becomes an agent run

A bug report starts as a conversation. Someone tags an agent such as @Devin or @Claude in that thread, and the agent creates a dedicated code channel scoped to the task. It inherits the originating discussion, including what went wrong and the exchanges that shaped the request. The channel becomes the unit of work.

Inside that channel, four tabs make the run inspectable. Conversation holds the exchange between people and agent, while Plan presents an automatically generated breakdown of the intended steps. Code diffs shows old and new lines side by side for everyone in the channel. Live preview shows running HTML output so the team can spot what breaks before they approve it. For a bug fix, these surfaces connect the original report to the proposed implementation and its visible behavior.

A human in the channel approves the result, with explicit sign-off required for high-stakes actions such as merging code to production. On completion, the channel archives automatically, leaving a searchable audit record of the request, changes, and approval.

Devin’s API also supports programmatic assignments from issue trackers, deploy hooks, Slack workflows, and scheduled jobs. One team used GitHub issues labeled “devin-ready” to trigger assignments that returned a PR within hours, illustrating how conversational and structured triggers can feed agent work.

How permissions and approvals keep the agent inside the team's trust boundary

Slack Code inherits existing permissions and admin controls rather than requiring IT to provision a separate identity layer. The invoking user defines the agent’s access boundary. A product manager tagging an agent cannot give it access beyond what that product manager already has. This ties delegation to the organization’s existing governance rather than treating an agent mention as unrestricted authorization.

Access alone does not authorize every consequential action. Slack Code requires a human in the channel to explicitly approve high-stakes actions such as merging code to production before they happen. The gate addresses a concrete failure mode, which is an agent taking consequential action without a person accepting the result. It separates permission to attempt work from permission to ship it.

Anyone in the channel can pause, redirect, or stop the agent, and the Agents & Tools tab lists agents and sessions across the app with a stop button. The automatic audit log records who triggered the task, what changed, and who approved it.

Security risks that survive the permission model

Channel permissions do not secure the execution layer underneath. Cato Networks disclosed CVE-2026-50548 and CVE-2026-50549, both rated 9.8 CVSS 3.1 and collectively named “DuneSlide,” in which prompt-injected commands manipulated working-directory and symlink-validation logic to overwrite the sandbox helper itself. The attack targeted the mechanism enforcing the boundary. Human approval and permission inheritance do not, by themselves, close that class of vulnerability.

Project-local configuration gives code another way to cross the boundary. Several agents trust files such as a.claude/settings.local.json hook definition or a.vscode task file as part of the infrastructure. They also trust a Python virtual environment’s interpreter binary in the same way. The agent can write these inside the sandbox, after which a separate tool can execute them unsandboxed.

What the agent's execution environment needs to do before the Slack trigger is safe to use at scale

The channel coordinates work, but the environment executes it. Standard containers share the host kernel, so they do not provide enough isolation for untrusted AI-generated code. The main isolation approaches are microVMs such as Firecracker and Kata Containers, gVisor with its user-space kernel, and hardened containers. MicroVMs provide the strongest isolation of these approaches because each workload has a dedicated kernel.

For production runs, the recommended pattern makes that separation explicit. Untrusted code runs in a microVM, while the agent loop and secrets stay outside the sandbox. Network egress passes through an allowlist. These controls address execution and access paths that Slack’s channel permissions do not govern. The collaboration surface cannot substitute for them.

Environment lifetime is a separate design decision. An ephemeral sandbox serves one task and is destroyed afterward, while a persistent sandbox survives between sessions to avoid repeated repository cloning and dependency installation. Cursor’s Builds, shipped August 13, 2026, boots cloud agents into a pre-configured environment instead of asking each agent to construct one from scratch. Starting from a known state with dependencies installed lets agents spend run time verifying their work. A cloud agent platform with isolated, fully configured VMs gives tasks triggered from Slack this environment to run in.

Which coding agents can a team trigger directly from Slack messages?

Slack Code is harness-agnostic, so its channels work the same way with each agent. But the agents run in different ways and are good at different tasks. Claude Code has a high software engineering benchmark score and a very large token context that helps it reason across codebases. Its Agent Teams feature supports multi-agent collaboration, while developer-in-the-loop steering lets people redirect work in real time.

Devin, from Cognition, positions itself as a full-service autonomous engineer. Its multi-agent orchestration lets parent sessions spawn child sessions in separate isolated VMs, with structured JSON output. This model suits autonomous backlog clearing and long-running assignments. Its API also provides a route from issue trackers and deploy hooks, extending delegation beyond a person tagging an agent in Slack.

GitHub Copilot offers a familiar base for daily development and native integration with the GitHub pull request workflow. Vercel’s agent has a narrower scope around frontend and deployment work for teams on its platform. Selection therefore depends on the task. A practical stack combines Copilot for routine development, Claude Code for complex reasoning, and Devin for autonomous backlog tasks, while retaining the same channel-based collaboration pattern.

What changes in the team's review workflow when agent PRs start arriving through Slack

Linear’s data casts doubt on the idea that agents simply give engineers time back. Agents produce more code, while specifying tasks, triaging output, and deciding whether changes are safe to merge create additional work. Review becomes the constraint downstream of generation. Faros AI found much longer median review times and a sizable rise in PRs merged without review. LinearB found that AI-assisted PRs took far longer at the 75th percentile than unassisted ones, with a much smaller share merging quickly.

The authorship of incoming work changes as well. Between June 2024 and June 2026, Linear measured a rise from a small to a meaningful share of product managers attaching pull requests to issues, with similar patterns among designers and founders. Those changes enter the queue for engineers to review even when their authors cannot answer questions about the design of the implementation.

With shared diffs, live previews, and approval gates, Slack Code lets more people see that review. Visibility is useful, but it is not scrutiny. A thumbs-up in a busy channel does not establish that a change received a code review. The review process should be designed with the trigger workflow, including who reviews and what they check, before generated PR volume exposes the gap.

How to measure whether Slack-triggered agent runs are actually producing value

Commit counts, lines of code, and hours in an editor become unreliable measures when agents can generate activity in seconds. Delivery includes lead time, deployment frequency, and DORA metrics. Quality includes change failure rate and code churn, with turnover materially above human-only baselines signaling work that needs immediate revision. Leverage measures how much work ships for the real effort put in.

These measures need to remain connected to each run. A Slack-originated task should retain its source thread, harness, model, and credential as it passes through execution and returns as a PR. Without that provenance, the overall results cannot show which combination led to useful work. The trace connects the request to the outcome. It also supports the distinction between an agent completing a run and its output actually merging.

Cognition reported a large increase in merged PR count with only a modest headcount increase. The useful signal is the relationship between output and staffing. For a team assessing its own workflow, quality and review effort belong beside that ratio. Otherwise, generating more code can look like better leverage while shifting work to revising and approving it.

Setting up a Slack-triggered agent workflow that a team can actually maintain

A team preparing to go live should choose the execution environment before the harness. An ephemeral VM per task provides a cleaner security boundary, while a persistent VM reduces repeated setup for work on the same codebase. Either choice requires more than a shared-kernel container baseline. The first agent should match the work most likely to arrive, with the execution platform supporting later harness changes without re-architecture.

Permission and review decisions should precede the first production trigger. The team should define who can invoke agents in which channels, then establish who reviews diffs and what the minimum review covers. Slack’s inherited permissions and approval gate provide enforcement points.

For Linear and Slack integration, conversational delegation and issue-driven automation serve complementary roles. Slack preserves the discussion that defines a task, while Devin’s API offers a programmatic route from issue trackers. The “devin-ready” example is specifically a GitHub integration, but it provides a useful model for structured delegation rather than evidence of a ready-made Linear connector. Finally, attribution should be instrumented before the first run so the team can connect each source thread to its agent and merge outcome.

Sources

  1. claude-code-ultimate-guide/guide/workflows/agent-teams.md at main · FlorianBruniaux/claude-code-ultimate-guide · GitHub
  2. 7 Best Cloud Coding Agents in 2026

More in Coding Agent Integrations