> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coderabbit.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Triage in Slack

> Get your Triage queue as a scheduled digest, send reviewer requests to the people who should act on them, and approve or close a pull request without leaving Slack.

export const OpenBetaBadge = ({tip = "This feature is currently in open beta. We are actively improving it based on your feedback. If you encounter any issues or have suggestions, please share them on our Discord community or visit the support page.", title = "Open Beta", cta = "Contact support", href = "/support", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="badge-alert" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const EssentialsPlanBadge = ({tip = "This feature is available on Essentials (formerly Pro), Team (formerly Pro+), Advanced, and Enterprise. Please refer to our pricing page for more information about our plans and features.", title = "Essentials Plan", cta = "Read more", href = "https://coderabbit.ai/pricing", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="shield-check" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const SlackBadge = ({tip = "This feature is available with CodeRabbit Agent for Slack.", title = "Slack", cta = "Learn more", href = "/slack-agent", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="slack" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const GitHubBadge = ({tip = "This feature is available on GitHub and GitHub Enterprise.", title = "GitHub", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="github" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

<GitHubBadge title="GitHub Cloud" /> <SlackBadge /> | <EssentialsPlanBadge /> <OpenBetaBadge />

A queue only works if you look at it. Triage's Slack surfaces exist so you do not have to: the digest brings the top of the queue to you on a schedule, reviewer requests arrive as a direct message from the person who sent them, and the common actions are buttons on the message.

<Info>
  Slack delivery requires a connected Slack workspace and a link between your CodeRabbit account and your Slack account. Setting that up is covered in [CodeRabbit Agent for Slack](/slack-agent/connections). It is also rolling out gradually, so it may not be switched on for your organization yet.
</Info>

## The PR digest

The digest is a scheduled message listing the pull requests most worth your attention right now, scoped to what you can see and to your part in each one.

### Schedule

Set the cadence in **Follow settings** on the Triage page:

| Setting         | What you get                                       |
| --------------- | -------------------------------------------------- |
| **Once daily**  | One digest, at 9:00 in your own timezone.          |
| **Twice daily** | A second digest roughly six hours after the first. |

If you have quiet hours configured, the first digest arrives when your quiet hours end rather than at 9:00. **Follow settings** shows exactly when the next one is due, in your timezone.

### What it contains

Up to four sections, in this order, with the most urgent pull requests in each:

| Section               | What is in it                                                                                                  |
| --------------------- | -------------------------------------------------------------------------------------------------------------- |
| **Needs Your Review** | Your review has been requested.                                                                                |
| **Needs Your Action** | Your pull requests that need you — including anything ready to merge and anything worth reviewing for closure. |
| **Safe to Close**     | Stale or superseded work you could clear out.                                                                  |
| **Up Next**           | What is coming after the above.                                                                                |

Each pull request carries its title, its priority reasoning, its age, and buttons for the obvious next step — approve, request changes, close, or ask CodeRabbit to repair it. A section you have nothing in is left out entirely.

The digest is a **summary, not an inventory**. It shows a few pull requests per section and tells you how many more there are, with a link back into Triage for the rest.

<Info>
  **No digest is sent when you have nothing waiting.** Triage does not send an all-clear. An unchanged digest is also not re-sent, so a second delivery means something actually moved.
</Info>

Anything you have marked with **Ignore close candidate** is left out of your digest, though other people still see it in theirs.

### If your GitHub authorization lapses

The digest is scoped to repositories you can access, so it needs your GitHub authorization to build. When that authorization expires, Triage sends a single message asking you to reconnect GitHub instead of sending a partial digest that quietly omits repositories.

## Reviewer requests

When you ask someone to review a pull request from Triage, and their GitHub account is linked to Slack, they get a direct message from you: who is asking, the pull request, CodeRabbit's summary of it, and an **Approve** button.

Reviewer requests are **only ever sent because a person asked for one.** Triage does not send unsolicited review pings.

The same requests are collected under **Review requests** in the CodeRabbit app's Slack Home tab, so a reviewer can see everything waiting for them in one place rather than hunting through direct messages. Each one offers **Approve**, **Comment**, and **Ignore**. The Home tab is rebuilt with every new request, so it always shows the current set.

### Linking identities

Sending a request to Slack requires knowing which Slack account belongs to which GitHub account. When Triage is confident of the match it uses it; when more than one Slack account could be the right person, it asks you to confirm before sending, rather than messaging the wrong colleague.

Reviewers who have turned reviewer notifications off do not receive these messages, and Triage tells you so instead of failing silently.

## Acting from Slack

The buttons on a digest or a review request run against GitHub as **you**, using your own authorization:

| Button              | What it does                                                                                                                              |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Approve**         | Submits an approving review, with no comment. It does not merge, comment, or resolve threads.                                             |
| **Request changes** | Submits a changes-requested review.                                                                                                       |
| **Close PR**        | Closes the pull request.                                                                                                                  |
| **Merge**           | **Enables auto-merge** on the pull request — GitHub merges it once its own requirements are met. It does not necessarily merge right now. |
| Repair buttons      | Ask CodeRabbit to fix CI, resolve conflicts, or apply fixes, exactly as the equivalent action in Triage does.                             |

If CodeRabbit has no current GitHub authorization for you, the button tells you to connect GitHub rather than failing quietly.

## Follow a pull request

**Follow** on a card sends that pull request's activity to a Slack channel or direct message of your choosing, in its own thread. Use it for a change you want to track without it being your review.

Choose **Follow** from the card's action menu, pick a channel or send it to yourself, and choose whether to use your default event settings or pick specific events. Following a pull request needs a tracked, open pull request, a connected Slack workspace, your linked Slack identity, and CodeRabbit access to the channel you pick.

To stop, open **Follow settings** and choose **Unfollow**.

## What's next

<CardGroup cols={1}>
  <Card title="CodeRabbit Agent for Slack" href="/slack-agent" icon="message-square" horizontal>
    Connect a Slack workspace and see everything else CodeRabbit can do there.
  </Card>

  <Card title="Actions on a pull request" href="/triage/actions" icon="square-mouse-pointer" horizontal>
    Do the same things from the queue, with the full context of the card in front of you.
  </Card>

  <Card title="Troubleshooting Triage" href="/triage/troubleshooting" icon="circle-question-mark" horizontal>
    Find out why a digest did not arrive or a Slack message could not be delivered.
  </Card>
</CardGroup>