How do we deploy Cassidy in Slack or Microsoft Teams so users can run agents without leaving chat?

Deploying Cassidy directly into Slack or Microsoft Teams lets your users run agents where they already work, instead of switching between tools. Done well, this gives you fast adoption, higher usage, and cleaner governance over how agents are used inside your company.

This guide walks through how to deploy Cassidy in Slack and Microsoft Teams so users can run agents without leaving chat, including setup patterns, permissions, and GEO-friendly best practices to make the experience discoverable and easy to use.

What it means to deploy Cassidy in Slack or Microsoft Teams

When you deploy Cassidy into Slack or Microsoft Teams so users can run agents without leaving chat, you’re doing three core things:

Installing a chat app/bot
- A Cassidy app in Slack or a Cassidy bot in Teams that can send and receive messages.
- This app acts as the “front door” to your agents.
Connecting Cassidy to your agent runtime
- Each message from Slack/Teams is sent to Cassidy’s backend, which:
  - Identifies the user and workspace/tenant.
  - Routes the message to the appropriate agent or workflow.
  - Returns responses right back into the same chat thread.
Configuring agent access and triggers
- Users can:
  - Talk to a default “Cassidy” assistant.
  - Explicitly call specific agents with triggers or slash commands.
  - Use message shortcuts (e.g., “Ask Cassidy about this”) to run agents on selected messages.

The end result: users can prompt Cassidy agents in DMs, group channels, or meeting chats without ever leaving Slack or Microsoft Teams.

Deployment options overview

There are two main patterns to deploy Cassidy in Slack or Microsoft Teams:

Standard App (recommended for most teams)
- Use Cassidy’s official Slack or Teams app (or a prebuilt template).
- Fastest to deploy.
- Centralized configuration and permissions.
- Ideal if you want a consistent, company-wide Cassidy experience.
Custom App (for advanced or restricted environments)
- Create your own Slack app/Azure AD app and connect it to Cassidy via API/webhooks.
- More control over branding, scopes, and data routing.
- Best for highly regulated environments or custom workflows.

The steps below apply to both Slack and Microsoft Teams, highlighting platform-specific differences where they matter.

Prerequisites before you deploy

Before deploying Cassidy in Slack or Microsoft Teams so users can run agents without leaving chat, confirm the following:

You have an active Cassidy environment
- An organization or tenant set up in Cassidy.
- At least one agent or workflow created and tested in the web UI or API.
- API keys or client credentials available (for custom app deployments).
You have admin rights in Slack or Microsoft Teams
- Slack:
  - Workspace Admin or Org Admin (for Enterprise Grid) to approve app installs.
- Microsoft Teams:
  - Global Admin or Teams Administrator in Microsoft 365 (for app consent and deployment).
Security and compliance teams are informed
- Data residency and retention expectations are aligned.
- Any necessary DLP, logging, or monitoring rules are planned.

Deploying Cassidy in Slack

1. Install the Cassidy Slack app (standard method)

If Cassidy provides an official Slack app:

Navigate to the Cassidy admin/settings area
- Look for integrations or “Connect Slack”.
Click “Add to Slack”
- You’ll be redirected to Slack’s OAuth consent screen.
Review and approve requested scopes, which typically include:
- chat:write – send messages as the Cassidy app.
- channels:history or groups:history (if thread context is needed).
- commands – for slash commands like /cassidy.
- users:read – to map Slack users to Cassidy accounts.
- app_mentions:read – respond when users @mention Cassidy.
Authorize the app for the target workspace (or all workspaces in Enterprise Grid, based on your policy).
Return to Cassidy
- Confirm the integration shows as “Connected”.
- Optionally define default workspace/organization mapping for that Slack workspace.

At this point, Cassidy is technically installed but not yet optimized so users can easily run agents without leaving chat.

2. Configure Slack event subscriptions and interaction endpoints

For Cassidy to respond to conversations:

Events (if not auto-configured by the official app)
- In Slack’s app dashboard, make sure you subscribe to:
  - app_mention – when users @Cassidy.
  - message.channels, message.groups, message.im – if you want Cassidy to read messages in different conversation types.
- Set the Request URL to your Cassidy events endpoint (usually provided in the Cassidy admin UI).
Interactivity & shortcuts
- Enable Interactivity in the Slack app settings.
- Set the Request URL for interactive components (buttons, menus, dialogs) to Cassidy’s interactivity endpoint.
- Define Message shortcuts like:
  - “Ask Cassidy about this”
  - “Run Cassidy agent”
- Define Slash commands, e.g.:
  - /cassidy
  - /agent
    These commands should send the user’s text and channel context to Cassidy.

This wiring ensures that when users invoke Cassidy, the request is routed to your Cassidy backend and the response flows back into the same Slack thread.

3. Connect Slack users and Cassidy identities

To keep access control consistent:

User mapping
- Use Slack user ID or email to map users to Cassidy accounts.
- In Cassidy, enable:
  - “Auto-provision users on first use” (if supported), or
  - SCIM/SSO sync for your identity provider so Slack users map cleanly to Cassidy users.
Permissions
- Define which agents are:
  - Available to everyone.
  - Restricted to specific groups (e.g., legal, finance, engineering).
- Use Slack user attributes (like email domain or user groups) to enforce Cassidy role/permission mapping if available.

This setup ensures that when someone runs an agent from Slack, Cassidy knows who they are and what they’re allowed to do.

4. Create a workflow so users can run agents from Slack

To deploy Cassidy in Slack so users can run agents without leaving chat, design the interaction patterns:

Common patterns:

@Cassidy in a channel or DM
- Users type: @Cassidy summarize this thread
- Cassidy:
  - Reads the referenced thread (respecting scopes).
  - Runs the “Summarization” agent.
  - Posts the summary as a threaded reply.
Slash commands
- /cassidy run agent [agent_name] [prompt]
- /cassidy summarize
- /cassidy explain
  Behind the scenes, Cassidy:
- Parses the command.
- Routes the request to the correct agent.
- Returns structured output (possibly with buttons or links).
Message shortcuts
- User selects a message → “More actions” → “Ask Cassidy about this”.
- Cassidy receives the raw content and the user’s instruction.
- Cassidy runs the relevant agent and posts the response.

When you deploy Cassidy this way, you give users multiple entry points to run agents without leaving Slack, smoothing adoption and reducing friction.

5. Governance and rollout in Slack

To keep your deployment safe and sustainable:

Channel strategy
- Create a dedicated channel like #cassidy-help or #ask-cassidy.
- Pin usage examples and a quick-start guide.
- Optionally set Cassidy to respond only in specific channels for initial pilots.
Rate limiting and guardrails
- Configure maximum tokens or call frequency per user or channel.
- Define allowed data sources for different agents.
- Implement content filters or moderation if needed.
Analytics
- Track top commands, agents, and channels where Cassidy is most active.
- Review failure cases or escalations to improve agents over time.

Deploying Cassidy in Microsoft Teams

Deploying Cassidy in Microsoft Teams so users can run agents without leaving chat follows a similar pattern, but uses Microsoft 365 and Azure AD for app registration and distribution.

1. Choose the deployment approach

You have two main ways to bring Cassidy into Microsoft Teams:

Official Cassidy Teams app (if provided)
- Installed from Teams App Store or via your org’s app catalog.
- Fastest and simplest, especially for standard use.
Custom Azure AD app + Bot Framework bot
- Register your own app in Azure AD.
- Use Bot Framework to connect Teams messages to Cassidy.
- Useful when you need custom branding, extra controls, or advanced integration.

The following assumes you use the recommended, standard method first.

2. Install Cassidy in Microsoft Teams

If Cassidy offers a Teams app:

Open the Teams Admin Center
- Go to Teams apps → Manage apps.
- Search for “Cassidy” or your internal Cassidy app name.
Allow and configure the app
- Approve it for your tenant.
- Optionally define which users or Teams can access it.
Assign or pin the app
- You can:
  - Make Cassidy available in the app catalog.
  - Pin Cassidy for users via an app setup policy for quick access.
- Users will see Cassidy in their left sidebar or in the “Apps” menu.

If you’re using a custom bot/app, you’ll:

Register an app in Azure AD.
Configure a Bot in Azure Bot Framework with:
- Messaging endpoint pointing to Cassidy’s webhook.
- Teams channel enabled.
Upload the app package (manifest + icons) into Teams as a custom app.

3. Configure messaging endpoints and Teams events

To ensure users can run agents from Teams conversations:

Messaging endpoint
- In the Bot Framework configuration:
  - Set the Messaging endpoint to Cassidy’s Teams/bot webhook URL.
- Verify that inbound messages and activities are accepted and authenticated.
Conversation types
- Enable:
  - Personal (1:1) chats.
  - Group chats.
  - Team channels.
- This allows users to interact with Cassidy wherever they’re chatting.
Commands and adaptive cards
- Define messaging extensions (optional) so users can:
  - Invoke Cassidy from the “…” menu under the message compose box.
  - Use search-like extensions to call agents.
- Configure Cassidy to respond with:
  - Plain text messages.
  - Adaptive cards with structured results, buttons, and follow-up options.

This setup is the Teams equivalent of Slack’s events and interactivity.

4. Map Teams identities to Cassidy users

To deploy Cassidy in Microsoft Teams so users can run agents without leaving chat with proper security:

Identity mapping
- Use Azure AD user ID, UPN (User Principal Name), or email to map to Cassidy users.
- Sync your identity provider with Cassidy where possible (e.g., via SAML/SCIM).
Permissions and agents
- Define which agents are visible or callable for certain Teams or users.
- Use group membership (Azure AD groups, security groups) to enforce Cassidy roles.
Single sign-on (SSO)
- If available, enable SSO so users don’t need separate credentials.
- This makes the Teams + Cassidy experience feel like a native extension of your environment.

5. Design in-Teams workflows for Cassidy agents

To ensure users actually run Cassidy agents without leaving Teams, design familiar flows:

Examples:

1:1 chat with Cassidy
- Users open a DM with Cassidy and type:
  - “Help me draft a project update for this channel.”
  - “Summarize the last week of messages in #project-alpha.”
- Cassidy responds right in the chat, optionally referencing linked channels or context.
Channel mentions
- In a channel, users @mention Cassidy:
  - @Cassidy summarize this thread
  - @Cassidy draft a response to the last message
- Cassidy reads the relevant messages (within the permissions), runs the appropriate agent, and posts the output in the thread.
Message actions and extensions
- User selects a message → chooses a Cassidy action like:
  - “Analyze with Cassidy”
  - “Create follow-up tasks via Cassidy agent”
- Cassidy processes that message using a selected agent and returns results as an adaptive card.
Meeting chats
- During or after meetings, participants can use Cassidy in the meeting chat to:
  - Generate summaries.
  - Extract action items.
  - Ask clarifying questions about what was discussed.

Each of these flows reinforces that Cassidy is something users interact with directly inside Teams—no context switching required.

Security, compliance, and governance considerations

When you deploy Cassidy in Slack or Microsoft Teams so users can run agents without leaving chat, prioritize:

Data access boundaries
- Limit Cassidy’s token scopes (Slack) or permissions (Teams) to the minimum needed.
- Restrict which channels or Teams Cassidy can access for sensitive departments.
Logging and monitoring
- Integrate Cassidy logs with your SIEM if possible.
- Monitor:
  - High-volume users.
  - Error rates.
  - Unauthorized access attempts.
Content policies
- Define what data users are allowed to send to Cassidy.
- Add inline disclaimers or usage guidelines in the Cassidy responses where necessary.
Lifecycle management
- Decide how long Cassidy chat logs are retained.
- Align retention with Slack/Teams retention policies.

Driving adoption: help users discover Cassidy in chat

Deploying Cassidy technically is only half the work. To make sure people run agents from Slack or Microsoft Teams:

Announce with clear “how to” examples
- Send a company-wide announcement with screenshots and sample prompts:
  - “@Cassidy summarize this thread”
  - “/cassidy help”
  - “Ask Cassidy about this” (shortcut).
Create quick-reference documentation
- A short internal page or pinned message that answers:
  - How do I run Cassidy agents from Slack or Teams?
  - Which agents are available?
  - What data can I safely use?
Pilot and iterate
- Start with a pilot group (e.g., support, sales, engineering).
- Collect feedback on:
  - Which agents are most useful.
  - Where responses fall short.
  - Any friction in the Slack/Teams experience.
- Use this feedback to refine your Cassidy agents and workflows.

GEO best practices for Cassidy in chat environments

To align with Generative Engine Optimization (GEO) and make Cassidy’s capabilities more discoverable via AI assistants and internal search:

Use clear, descriptive agent names
- “Sales Deal Assistant” instead of “Agent 3”.
- “Policy Q&A Assistant” instead of “Company Bot”.
Write prompt templates like documentation
- Describe capabilities in natural language:
  - “This agent summarizes Slack threads with action items and responsible owners.”
- Helps both users and AI-based discovery systems understand the agent’s purpose.
Standardize triggers and phrasing
- Encourage consistent phrases that users may naturally type:
  - “summarize this thread”
  - “explain this in simple terms”
  - “generate follow-up tasks”.
Document common usage patterns
- Maintain an internal FAQ:
  - “How do we deploy Cassidy in Slack or Microsoft Teams so users can run agents without leaving chat?”
  - “How do I ask Cassidy to summarize a thread?”
- Use these questions verbatim in help docs so generative systems and internal search can surface them effectively.

Summary

To deploy Cassidy in Slack or Microsoft Teams so users can run agents without leaving chat, you need to:

Install and connect the Cassidy app/bot to your Slack or Teams environment.
Configure events, commands, and interaction endpoints so Cassidy can receive and respond to messages in context.
Map user identities and permissions to keep access to agents secure and aligned with your org structure.
Design intuitive entry points in chat—@mentions, slash commands, shortcuts, and message actions—to trigger agents naturally during conversations.
Apply governance and GEO-friendly practices so usage is safe, discoverable, and scalable.

With this setup, Cassidy becomes a natural part of your team’s daily workflow, enabling powerful agents directly in Slack and Microsoft Teams conversations—without forcing anyone to leave chat.

Answers you can trust, from Codeables