# Slack turns channels into the context engine for agentic AI | LinearB Blog

> Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is integrating the open Model Context Protocol (MCP) to avoid proprietary software dependency, how to manage agent identity and security, and the operational realities of putting custom bots directly on your corporate org chart.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Slack turns channels into the context engine for agentic AI",
      "item": "https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

Slack turns channels into the context engine for agentic AI

# Slack turns channels into the context engine for agentic AI

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels#andrew-zigler)

|

July 15, 2026

![Blog_Post_Name_2400x1256_077524ba8b](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_077524ba8b?_a=BAVMn6ID0)

[Jaime DeLanghe](https://linearb.io/dev-interrupted/podcast/slack-jaime-delanghe-agentic-workflows-model-context-protocol), Chief Product Officer at Slack, has spent eight and a half years watching the product mature from a place people fanboy over into a platform that pulls the whole company into a single conversation. She started her Slack tenure in search and machine learning, arriving with ambitions to turn the information trapped in channels into usable knowledge. That vision, once lofty, is now something the product can actually deliver.

DeLanghe now sits at the center of one of the more consequential design questions in enterprise software, namely how humans and AI agents share the same workspace without either one degrading the other. Her answer draws directly on what has always made Slack work, and it reframes the humble channel as the foundational primitive for the agentic era.

## Slack is engineering human-agent collaboration to stay human at its core

The single biggest design risk DeLanghe sees in the agentic era is fragmentation, the pull toward isolated AI chambers where people work only with robots in one space and only with humans in another. Slack's explicit bet is that those spaces must combine. "I think these spaces need to blend a lot," she argues, and the mechanism for blending them already exists.

Channels were always two things at once, a digital container for arbitrary objects and an access control list. That dual nature makes them ideal for mixed human-agent teams, because a builder can point an agent at a project without stitching together a separate knowledge graph. As DeLanghe explains, one of the toughest problems in building an agent is figuring out the context layer, and channels carry just enough structure to name a topic without imposing rigid scaffolding.

The richest signal turns out to be the conversation itself. The messy back-and-forth around a slide deck or a [pull request](https://linearb.io/platform/programmable-workflows/features), DeLanghe notes, is exactly what lets an agent act intelligently, because the more it knows about what happened around an artifact, the smarter it can be. Good communication hygiene and good agent performance become the same discipline. Slackbot, in her framing, can act as a super-orchestrator coordinating multiple agents while the surrounding human conversation keeps them grounded in real organizational intent. "Slack needs to evolve to make humans and agents work together super well, make it the best place to develop your agents, deploy your agents," she says.

## MCP integration gives enterprise AI the distribution layer it actually needs

"The move to MCP was pushed in a lot of ways by the community telling us that it's what they needed," DeLanghe recalls. Developers were already bending Slack's APIs toward uses they were never designed for, in ways the team found unsecure and uncomfortable. The [MCP server](https://linearb.io/platform/mcp-server) became the safe, scalable answer to demand that had already outpaced the platform.

On the client side, Slack ran the experiment inside its own walls first. The team connected MCPs of deliberately varying quality to Slackbot, worried that people might publish junk and degrade the agent experience past the point of usefulness. Letting a heterogeneous ecosystem grow internally proved the point. Good tool selection and good logic around that selection could survive a noisy server environment, which cleared the way to open MCP to partners.

DeLanghe is careful to position MCP as a complement to the existing platform rather than a replacement. Six months ago the team debated whether to keep investing in Block Kit at all. A group drawn from platform, user experience, and front-end engineering settled the question by extending Block Kit into a translation layer for MCP-generated UI, so developers already invested in Slack primitives do not have to pivot their entire stack. Block Kit still matters, DeLanghe points out, it just means something more flexible now. She also previews putting MCP on top of admin tooling, so large enterprises managing Slack at scale can talk to a Slack admin bot in natural language rather than wrestling a dashboard.

## Slack is becoming the definitive platform to deploy and discover AI agents

DeLanghe reaches for an analogy that is deliberately grand. For the companies that use it, Slack is doing for their agents what Google did for the internet. It makes agents discoverable, gives them an audience, and provides something functionally equivalent to backlinks, a relevance and trust signal that lives inside the organization. 

The channel model solves the deployment problem that trips up most builders, the need for a living context layer that stays current without a bolted-on knowledge graph. Because a channel already points at a project or a topic, the context refreshes itself as the conversation moves. Slack's low-code and no-code heritage keeps the deployment bar low enough that a business owner, not only a developer, can ship something useful. DeLanghe frames this as the original mission carried forward, the drive to make everybody a maker, extended now to agents.

The security dividend is the part builders tend to overlook. Because agents talk over the same protocol as humans, enterprises inherit Slack's existing compliance stack at deployment time. [Data loss prevention](https://linearb.io/blog/data-quality-foundation-ai-software-development) can flag an attempt to feed an agent a credit card number and exfiltrate data. Anomaly detection can catch behavior that looks like a compromised account or a malicious agent. Legal holds, strong auditability, and enterprise key management all come along. People rolling their own agent UI, DeLanghe notes, are usually not thinking about any of that, and if they are, it is rarely their primary concern.

## Agent identity and ownership must be solved before enterprise trust can scale

Identity is where DeLanghe admits the picture is still shaking out. Two models are emerging. In the first, an agent holds its own first-class identity, with its own account in the tools it touches. In the second, the agent operates on an OAuth pass-through, acting strictly on behalf of the authenticated human and logging any independent action back to that person. Different use cases, she argues, will canonically require one or the other, and a single rule cannot fit everything.

The customer example she keeps returning to is Assemble, which placed hundreds of agents directly on its org chart. Each agent has a manager, each is owned by a business owner, and each is treated like an employee with [performance metrics](https://linearb.io/blog/software-development-metrics-guide) to hit. That org chart is reflected inside Slack, so anyone can see who is responsible for a given agent. Modeling ownership the same way a company models headcount makes ROI tractable, because you can finally attribute an agent's contribution to a channel's objective.

Observability is the connective tissue holding the model together. DeLanghe wants builders to receive proactive insights when their agents produce value downstream, and she wants end users to trace a helpful answer back to the person who built the agent, closing the accountability loop. "My kind of holy grail there is if you could sort of get close to treating agents like employees and saying, this is the performance metric for," she says, sketching a world where an agent's work reads as clearly as a teammate's. Fine-grained admin provisioning is the control plane underneath all of it, specifying which people can operate which agents and which channels an agent is allowed to join, so that a proliferation of unmanaged agents never becomes an audit liability.

## Open standards for AI agent interoperability will outlast any single vendor's bet

Slack cannot afford proprietary lock-in at the agent layer, and DeLanghe is blunt about why. Anyone thinking about building agents needs to be able to build for Slack, and anyone building agents needs to drop them into Slack easily. That requires open standards, not Slack-specific ones. She is watching Skills over MCP closely, wants it as soon as humanly possible, and describes skills and MCP as going together like peanut butter and jelly. She is also testing A2A and other proposals, treating the whole landscape as something to tinker with rather than a race to pick an early winner.

The caution is strategic. With thousands of [developers building on the platform](https://linearb.io/blog/how-platform-engineering-fills-skill-gaps-to-improve-developer-experience), betting wrong means architectural debt spread across an entire ecosystem. DeLanghe reads the broader market the same way. Consolidation around a single vendor in any layer of the agent service architecture looks premature to her, and she observes an almost immediate community backlash whenever a consolidation narrative takes hold, a signal that people are not there yet. "Standardizing on things like MCP that are open, that people can contribute to, that feels like that's a moment for the community to get together and figure out where we're going, and I love that," she says.

The through-line across every one of DeLanghe's answers is that the durable foundation is not any single company's platform but the shared, contributable protocols the community builds together. Standardizing early lowers future switching costs, and keeping enough flexibility to absorb the next specification update keeps a team from being trapped when the interoperability stack, still being written in real time, shifts again. Slack's job, as she describes it, is to be both the lake where knowledge gathers and the river that carries a sense of the current, so teams always know what is most recent and most relevant. That combination, context plus velocity, is what turns a channel into an engine.

To hear more of Jaime DeLanghe's insights on human-agent collaboration in Slack, MCP integration for enterprise AI, and agent identity and observability, listen to the full episode on the Dev Interrupted podcast.

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for Your software factory needs a context layer](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

AI

[Your software factory needs a context layer](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption...

[![Cover image for You can now measure AI ROI with LinearB](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_1_dd1f47bae7?_a=BAVMn6ID0)](https://linearb.io/blog/ai-roi-dashboard)

AI

[You can now measure AI ROI with LinearB](https://linearb.io/blog/ai-roi-dashboard)

Today, we're launching the AI ROI dashboard in LinearB, live now for every customer with metrics builder enabled.

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

AI

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Slack turns channels into the context engine for agentic AI",
  "url": "https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-07-15T07:00:00.000Z",
  "dateModified": "2026-07-15T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1784154225/Blog_Post_Name_2400x1256_077524ba8b.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is integrating the open Model Context Protocol (MCP) to avoid proprietary software dependency, how to manage agent identity and security, and the operational realities of putting custom bots directly on your corporate org chart."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)