> For the complete documentation index, see [llms.txt](https://docs.bito.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.bito.ai/ai-architect/integrating-ai-architect-with-your-tools/integrating-with-slack.md).
# Integrating with Slack
Bito AI Assistant brings powerful AI capabilities directly into your Slack workspace. Instead of switching between apps or losing context, you get instant AI assistance right where your team collaborates.
Ask Bito to summarize lengthy threads, analyze code snippets, provide technical guidance, or help with planning. Bito reads the full thread context, understands shared files, and automatically pulls in information from Jira tickets and Confluence pages when you reference them.
Ask Bito to help with planning, provide technical guidance, analyze code snippets, summarize lengthy threads, run a full code review on a PR or branch, or open merge requests. Bito reads the full thread context, understands shared files, and automatically pulls in information from Jira tickets and Confluence pages when you reference them.
With Bito in your Slack channels, you save time catching up on discussions, make faster technical decisions, and keep your team's knowledge accessible.
Click the button to add the Bito AI Assistant to your Slack. [
](https://slack.com/oauth/v2/authorize?client_id=2061955158613.10908115946784\&scope=users:read.email,app_mentions:read,channels:history,channels:read,chat:write,files:read,files:write,groups:history,groups:read,im:history,im:read,mpim:history,mpim:read,reactions:write,users:read\&user_scope=)
{% hint style="info" %}
**⚠️ AI Disclaimer**
The Bito Slack app is powered by large language models (LLMs). AI-generated responses may be **inaccurate, incomplete, biased, or outdated**. Outputs are informational suggestions, not professional, legal, financial, medical, or compliance advice. Always verify critical information independently.
For full details on which LLMs are used, what data is sent, and training policies, see [**Slack App – Data Handling**](/privacy-and-security/slack-app-data-handling.md).
Report inaccurate responses to [**support@bito.ai**](mailto:support@bito.ai).
{% endhint %}
## Prerequisites
Before you install Bito AI Assistant, ensure you have:
* A [**Bito account**](https://alpha.bito.ai/home/welcome) with an active paid plan that includes Bito AI Assistant for Slack
* **AI Architect** set up for your Bito account:
* [Bito-hosted](/ai-architect/installation/install-ai-architect-bito-hosted.md) (Fully managed by Bito — no infrastructure setup required)
* [Self-hosted](/ai-architect/installation/install-ai-architect-self-hosted.md) (Run AI Architect on your own infrastructure for maximum control)
* **Slack admin permissions** to install apps in your workspace
## Installation steps
Installation takes less than 2 minutes. Once complete, every team member in invited channels can interact with Bito.
{% stepper %}
{% step %}
### **Add the app to Slack**
1. Go to [bitoaiassistant.bito.ai/slack/install](https://bitoaiassistant.bito.ai/slack/install)
2. Review the permissions and click **Allow**
3. Connect your Bito account when prompted
{% endstep %}
{% step %}
### **Invite Bito to channels**
1. Open any Slack channel where you want AI assistance
2. Invite Bito's AI Assistant to a channel by typing `@Bito` followed by your query. Slack will automatically prompt you to add Bito to the channel if it isn't already there, click **Yes** to add it and get your answer, or dismiss the prompt to skip.
3. Repeat for each channel (both public and private channels work)
{% endstep %}
{% step %}
### **Start using Bito**
1. In any channel where you invited Bito, type `@Bito` followed by your question
2. Bito reads the thread and responds with context-aware answers
{% endstep %}
{% endstepper %}
## How to use Bito AI Assistant
#### Basic usage
Mention `@Bito` in any message to get AI assistance. Bito reads the entire conversation thread, not just your message, so it understands the full context.
**Example:**
```
@Bito Based on the above discussion create a plan
```
Bito analyzes the thread and generates a structured, actionable plan based on the discussion.
{% hint style="info" %}
When you ask about "this thread" — for example "summarize this thread" or "what was discussed above" — Bito scopes its context to thread messages only and won't mix in unrelated channel history. Each message also carries a permalink, so Bito can point back to specific messages when it references them.
{% endhint %}
#### Asking questions
You can ask Bito questions in natural language. Be specific about what you need:
**Good questions:**
* `@Bito PROJ-456 is causing errors in production — here are the logs. Identify the root cause?`
* `@Bito help us break this feature into smaller tasks`
* `@Bito explain the difference between these two approaches`
* `@Bito what are the action items from this thread?`
* `@Bito review the code changes in this thread and suggest improvements`
**Tips for better responses:**
* Ask specific questions rather than general ones
* Reference what you're asking about if the thread contains multiple topics
* Use follow-up questions to dive deeper into a response
#### Working with files
When you share files in a Slack thread, Bito automatically processes them and incorporates their content into its responses.
**Supported file types:**
* Code files (`.py`, `.js`, `.java`, etc.)
* Configuration files (`.yaml`, `.json`, `.xml`)
* Documents (`.txt`, `.md`, `.pdf`)
* Log files
**Unsupported file types:**
Bito skips the following file types during processing. If any of these are attached to a Slack conversation, Bito will ignore them and continue processing the rest of the thread.
* **Executables & binaries:** `.exe`, `.dll`, `.so`, `.dylib`, `.a`, `.lib`, `.bin`, `.o`, `.obj`, `.sys`, `.app`, `.deb`, `.rpm`, `.apk`, `.msi`, `.elf`, `.mach`
* **Images & graphics:** `.jpg`, `.jpeg`, `.png`, `.gif`, `.bmp`, `.ico`, `.tiff`, `.webp`, `.heic`, `.psd`, `.eps`
* **Media files:** `.mp4`, `.avi`, `.mov`, `.mkv`, `.flv`, `.wmv`, `.mp3`, `.wav`, `.flac`, `.aac`, `.m4a`, `.ogg`, `.m3u`, `.m3u8`, `.pls`
{% hint style="info" %}
If your thread contains a mix of supported and unsupported files, Bito will process the supported ones and silently skip the rest.
{% endhint %}
**Example workflow:**
1. Upload a config file to the channel
2. Ask: `@Bito review this configuration and suggest improvements`
3. Bito reads the file and provides specific recommendations
#### Understanding integrations
Bito automatically detects and incorporates information from:
**Jira tickets**
* Mention a ticket ID like `PROJ-123` in your conversation
* Bito recognizes the reference and pulls in context from that ticket
**Confluence pages**
* Paste a Confluence link in your discussion
* Bito reads the linked page and factors it into its response
You don't need to do anything special — just mention or paste the link as you normally would.
## 1:1 direct message with Bito
You can chat with Bito AI Assistant privately, just like you would with any teammate. In a 1:1 DM, you do not need to mention `@Bito` — every message you send is automatically processed by the bot.
#### How to start a 1:1 chat
1. In Slack, click Apps in the left sidebar
2. Select Bito AI Assistant
3. Start typing your message and press Enter
#### What you can do
* Ask questions directly: `what does this function do?`
* Share files for analysis: attach a file and ask `can you review this code?`
* Have a conversation: follow-up messages maintain context from the thread
**Example:**
```
You: Can you help me understand what this code does?
[uploaded: authentication.py]
Bito: This file implements JWT-based authentication with three key functions...
```
{% hint style="info" %}
**Notes:**
* Every message you type in the 1:1 DM with Bito is processed — there is no need to prefix with `@Bito`
* Message edits: if you edit a message to add a new `@Bito` mention, Bito will respond to the new request
{% endhint %}
## Group direct message with Bito
You can also include Bito AI Assistant in a group chat with other teammates. This is useful when collaborating on a discussion where you want Bito's input along side human participants.
#### How to create a group DM with Bito
1. In Slack, click the "New Message" or pencil icon at the top of the left sidebar
2. In the **"To:"** field, add the teammates you want to include
3. In the same **"To:"** field, add Bito AI Assistant (start typing "Bito" and select it from the dropdown)
4. Send your first message to create the group
{% hint style="info" %}
**Important:** Bito must be added to the group at the time of creation. Slack does not allow adding bots to an existing group DM. If you want to add Bito to an ongoing conversation, create a new group DM or use a private channel instead.
{% endhint %}
#### Talking to Bito in a group DM
Unlike 1:1 DMs, in a group DM you must explicitly mention `@Bito` when you want Bito to respond. Messages without a mention are treated as normal conversation between humans and Bito will not respond.
**Example:**
```
You: Hey team, quick question about the new API design?
[Bito does not respond — no mention]
Alice: I think we should use REST for consistency.
You: @Bito AI Assistant what are the tradeoffs between REST and GraphQL
for our use case?
Bito: Great question. Here's a breakdown of the tradeoffs...
```
{% hint style="info" %}
**Notes:**
* Only messages containing `@Bito` trigger a response in group DMs
* Message edits trigger Bito only if a new mention is added during the edit (Bito will not respond to unrelated text edits on messages it has already replied to)
{% endhint %}
## Teach Bito workspace-specific facts
Bito learns from your team. Anyone in the workspace can teach Bito a fact, a piece of internal terminology, or a correction — and Bito applies that knowledge automatically in future answers, across channels, threads, and DMs.
**How it works**
When you correct Bito or share a workspace-specific fact, Bito stores it as a shared note for your workspace. The next time the topic comes up, Bito uses the note and attributes it back to who taught it.
**Examples**
```
@Bito remember that "Cerberus" refers to our internal auth service, not the open-source library
@Bito FYI — staging deploys go through the deploy-staging job, not deploy-stg
@Bito that's not right, our retry budget is 3 attempts, not 5
```
The next time anyone in the workspace asks about Cerberus, staging deploys, or retry budgets, Bito will apply the corrected information and note where it came from.
{% hint style="info" %}
Workspace learnings are shared across your entire Slack workspace, so a single teaching moment in one channel benefits the whole team.
{% endhint %}
## Common use cases
#### Break down complex work
Your team needs to implement a new feature but isn't sure where to start.
**What to do:**
```
@Bito help us break down this feature into implementable tasks
```
**What you get:**
* Suggested task breakdown
* Logical sequencing
* Considerations from your team's discussion
#### Turn plans into code
Your team has discussed and finalized an implementation plan in a thread and wants to move straight to coding.
**What to do:**
```
@Bito based on the implementation plan above, create a new branch and make the code changes
```
**What you get:**
1. A new branch created from your default branch
2. Code changes implemented following the agreed plan
3. Changes aligned with your existing codebase patterns and conventions
#### Review technical decisions
Your team discusses two different architectural approaches.
**What to do:**
1. Share code snippets for both approaches
2. Ask: `@Bito compare these two approaches and explain the trade-offs`
**What you get:**
* Analysis of each approach
* Pros and cons
* Recommendations based on the discussion context
#### Pull context from tickets
You're discussing a bug that relates to an existing Jira ticket.
**What to do:**
1. Mention the ticket: "This might be related to PROJ-456"
2. Ask: `@Bito what's the background on PROJ-456 and how does it relate to this issue?`
**What you get:**
* Summary of the referenced ticket
* Connection to current discussion
* Relevant history or context
#### Extract action items
After a long planning discussion, you need to know what comes next.
**What to do:**
```
@Bito list all action items from this thread with who's responsible
```
**What you get:**
* Organized list of tasks
* Assignments (when mentioned in the thread)
* Priorities or deadlines discussed
#### Catch up on long threads
You return from vacation to find 100+ messages in a project channel.
**What to do:**
```
@Bito summarize the last 3 days of discussion and highlight any decisions that need my input
```
**What you get:**
* Key points from the conversation
* Decisions already made
* Open questions requiring your attention
#### Review code from Slack
You want a real code review on a pull request, branch, commit, or local changes — without leaving Slack.
**What to do:**
Paste a link of pull request or describe what to review:
```
@Bito review https://github.com/your-org/repo/pull/1234
@Bito review the auth-refactor branch
@Bito review commit a1b2c3d
@Bito review my staged changes
```
You can narrow the review with flags:
```
@Bito review pull/1234 --focus security --depth deep
```
**What you get:**
* Severity-rated findings covering correctness, security, and performance
* Evidence quoted from the code with exact `file:line` references
* Cross-repo impact analysis when AI Architect is set up for your repo
* Actionable suggestions, not generic advice
{% hint style="info" %}
This is powered by the `bito-code-review` skill. See the [**Agent skills**](/ai-architect/agent-skills.md) page for the full list of supported review targets and flags.
{% endhint %}
#### Create a merge / pull request from Slack
After Bito makes code changes — or on any existing branch — you can open a merge request or pull request without switching tools.
**What to do:**
```
@Bito create an MR for the auth-refactor branch
@Bito open a draft PR with these changes
```
**What you get:**
1. A new MR or PR opened on GitHub, GitLab, or Bitbucket (cloud or self-hosted)
2. Title, description, and ticket references filled in automatically
3. Smart template detection — your repo's PR/MR template is used when present
4. Duplicate-MR guards so you don't accidentally open the same MR twice
5. Draft MR/PR support when you want to share work-in-progress
## Best practices
#### Get the most from Bito
**Do:**
* ✅ Ask specific, focused questions
* ✅ Use Bito in threads where team discussions happen
* ✅ Reference files and tickets to give Bito more context
* ✅ Ask follow-up questions to clarify responses
* ✅ Use Bito to document decisions by asking for summaries
**Don't:**
* ❌ Ask multiple unrelated questions in one message
* ❌ Expect Bito to make decisions for you — use it to inform your decisions
* ❌ Share sensitive credentials or secrets in threads (Bito reads all messages)
## Privacy and context
**What Bito can see:**
* All messages in the current thread
* Files shared in the thread
* Content from referenced Jira/Confluence links (if connected)
**What Bito cannot see:**
* Messages in channels where it hasn't been invited
* Direct messages between users
* Private channels where it's not a member
Always invite Bito only to channels where AI assistance is appropriate for your team's privacy requirements.
## Troubleshooting
#### Bito doesn't respond
**Check:**
1. Did you invite Bito to this channel? If not, invite Bito's AI Assistant to a channel by typing `@Bito` followed by your query. Slack will automatically prompt you to add Bito to the channel if it isn't already there, click **Yes** to add it and get your answer, or dismiss the prompt to skip.
2. Did you mention `@Bito` at the start of your message?
3. Is your Bito subscription active and does it include Bito AI Assistant for Slack?
**Solution:** Verify Bito is in the channel members list. If not, invite it again.
#### Bito's response seems incomplete
**Possible reasons:**
* The thread context is very long
* Multiple topics are discussed simultaneously
**Solution:**
* Ask more specific questions that focus on one aspect
* Reference the specific part of the conversation you're asking about
* Break complex questions into smaller parts
#### Bito doesn't see my Jira ticket
**Check:**
1. Is your Bito account connected to Jira?
2. Did you mention the exact ticket ID (e.g., `PROJ-123`)?
3. Do you have access to that ticket in Jira?
**Solution:** Verify integrations are configured in your Bito account settings.
#### I need to remove Bito from a channel
**Steps:**
1. Open the channel
2. Click the channel name to view details
3. Go to the **Integrations** tab
4. Find Bito and click **Remove**
Bito will no longer see messages or respond in that channel.
## Frequently Asked Questions
#### Does Bito read all messages in a channel?
Bito only reads messages in threads where someone mentions `@Bito`. It doesn't process or store messages from conversations where it's not mentioned.
#### Can I use Bito in private channels?
Yes. Invite Bito to private channels the same way you would invite any team member. Only people in that private channel can interact with Bito there.
#### How much does Bito AI Assistant cost?
Bito AI Assistant is included in Bito's paid plans. Check [bito.ai/pricing](https://bito.ai/pricing) for current plan details and features.
#### Does Bito learn from our conversations?
Bito uses conversation context to provide better responses during that discussion. Your team's specific conversations are used to improve responses within your Bito account but are not used to train public AI models.
#### What happens if I exceed my plan limits?
Bito will notify you when you approach plan limits. Responses may be rate-limited if you exceed usage caps. Upgrade your plan to increase limits.
#### Can I use Bito for customer support channels?
Yes, but consider privacy implications. Bito reads all messages in threads where it's mentioned. Only use it in channels where AI assistance is appropriate.
## Next steps
Now that you understand how Bito AI Assistant works:
1. **Invite Bito** to your most active project channels
2. **Try common use cases** like summarizing threads or extracting action items
3. **Share with your team** so everyone knows how to use `@Bito`
4. **Experiment** with different types of questions to discover what works best for your workflow
Welcome to faster, smarter team collaboration with AI assistance right in Slack.
## Related Resources
* 🔒 [Slack App – Data Handling](/privacy-and-security/slack-app-data-handling.md) — retention, deletion, LLM info, security
* :shield: [Bito Privacy and Security](/privacy-and-security.md) — overall security posture, SOC 2, sub-processors
* 💬 [Get Support](/help/support-and-questions/getting-support.md) — contact our team
* 📜 [Bito Privacy Policy](https://bito.ai/privacy-policy/) — full legal privacy policy
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.bito.ai/ai-architect/integrating-ai-architect-with-your-tools/integrating-with-slack.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.