> ## 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

> Work one cross-repository queue of open pull requests, ranked by what each change needs and what it is worth, instead of one repository list at a time.

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 TeamPlanBadge = ({tip = "This feature is available on Team (formerly Pro+), Advanced, and Enterprise. Please refer to our pricing page for more information about our plans and features.", title = "Team Plan", cta = "Read more", href = "https://coderabbit.ai/pricing", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="shield-plus" 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" tip="Triage is available on GitHub Cloud. GitHub Enterprise Server is not supported." /> | <TeamPlanBadge /> <OpenBetaBadge tip="Triage is in beta and is enabled per organization." />

CodeRabbit Triage is a single queue of every open pull request your organization is tracking, ordered by what each one needs next and what acting on it is worth. It is built for the person who has more pull requests in front of them than review hours: a reviewer, a code owner, a maintainer, or a team lead deciding what to pick up now.

Your Git provider already lists pull requests. It lists them one repository at a time, ordered by when someone last touched them, and it knows only mechanical state — open, approved, checks red. Triage adds what CodeRabbit learned while reviewing the change: how risky it is, how much of the system it touches, how much effort a review will take, who is best placed to do it, whether anything downstream is blocked behind it, and whether it is still worth finishing at all. Those signals are combined into one ranking across every repository you can see.

Open Triage at [app.coderabbit.ai/triage](https://app.coderabbit.ai/triage), or from **Triage** in the app sidebar.

## The card

The unit of work in Triage is a **card**: one open pull request, identified by its organization, repository, and pull request number. Everything in Triage is a statement about a card — its priority, its next action, its risk, who should look at it, and what you can do to it without leaving the queue.

A card is a **projection**, not a live window onto your provider. CodeRabbit maintains it from provider events and from its own review results, so it stays current without polling GitHub on every page load. Two consequences are worth knowing before you act on one:

* A card can lag the provider by a short interval, and a recent timestamp on a card does not prove that every field on it was refreshed at the same moment. Different signals arrive from different sources.
* Signals derived from a CodeRabbit review describe the commit that was reviewed. When an author pushes a newer one, some of those signals are withdrawn rather than shown against code they no longer describe. See [Signal freshness](/triage/cards#signal-freshness).

<Info>
  When a decision is expensive to get wrong — closing someone else's work, or merging — open the pull request and confirm the current state before you act.
</Info>

Opening a card takes you to [Change Stack](/change-stack) when it is available for that pull request. Otherwise, Triage opens the pull request in GitHub or GitLab.

## Availability

| Requirement  | Detail                                                                                                                                                             |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Plan         | Team or higher. See [Plans](/management/plans).                                                                                                                    |
| Git provider | GitHub Cloud. Triage cannot be opened by GitLab, Bitbucket, or GitHub Enterprise Server organizations, and is not available on self-hosted CodeRabbit deployments. |
| Organization | Must be backed by an active CodeRabbit workspace, and you must be a member of it.                                                                                  |
| Rollout      | Triage is in beta and is enabled per organization. Meeting every requirement above does not guarantee that it is switched on for yours yet.                        |

If Triage does not open for you, the page tells you which of these is missing — see [Troubleshooting Triage](/triage/troubleshooting#when-triage-will-not-open).

Triage shows only the repositories you can see. Membership in the CodeRabbit organization is not enough on its own: the queue is scoped to the repositories your signed-in GitHub account can access, and archived repositories are excluded.

## Viewing and acting

Any member of an eligible organization can **open Triage and read the queue** without a Review seat. Reading includes every view, filter, grouping, and card signal.

Actions that write to your Git provider or spend model capacity require an **active Review seat**:

| Action                                                     | Review seat  |
| ---------------------------------------------------------- | ------------ |
| Browse, filter, group, and save views                      | Not required |
| Read every signal on a card                                | Not required |
| Dismiss a safe-close recommendation, or report it as wrong | Not required |
| Start a CodeRabbit review                                  | Required     |
| Close a pull request                                       | Required     |
| Request, remove, or re-request a reviewer                  | Required     |
| Set a manual priority                                      | Required     |

Provider-writing actions additionally run as **you**, using your own GitHub authorization — Triage never acts as a shared bot identity for them. An action you are not permitted to perform in GitHub is refused in Triage too. See [Seat assignment](/management/seat-assignment) for how seats are granted.

Use **Follow** on a tracked, open pull request card to select a Slack channel or direct-message group and receive pull request activity in a dedicated thread. The direct-message option preselects you, and the picker lists recently used, accessible channels before you search. For the shared destination, identity-linking, event-preference, and autofix mechanics, see [Slack and Discord threads](/change-stack/notifications).

## Working the queue

The first time through, this is the whole loop:

<Steps>
  <Step title="Start where you are needed">
    You land on **Requires my action** — the pull requests you authored plus the ones you are reviewing, ranked. If you would rather see everything, switch to **All PRs** in the left rail.
  </Step>

  <Step title="Read down, not across">
    The order is the recommendation. Each card names its priority, the one thing that has to happen next, and a line explaining why it is ranked where it is.
  </Step>

  <Step title="Act from the card">
    Open it in Change Stack to review, or take the next action directly — start a CodeRabbit review, repair failing CI, find a reviewer, close it. See [Actions on a pull request](/triage/actions).
  </Step>

  <Step title="Narrow it once, then keep it">
    When you find a slice you keep coming back to — one repository, one risk level, work waiting on you — [save the view](/triage/views-and-filters#saved-views) rather than rebuilding the filters each morning.
  </Step>
</Steps>

Two things are worth a look on day one: **Safe to close**, which is usually where a long-lived repository has the most to gain, and [Triage in Slack](/triage/slack), which sends the top of the queue to you instead of waiting for you to visit.

## How this section is organized

| Page                                                    | The question it answers                              |
| ------------------------------------------------------- | ---------------------------------------------------- |
| [Cards and signals](/triage/cards)                      | What is this card telling me?                        |
| [How Triage prioritizes](/triage/prioritization)        | Why is this pull request at the top?                 |
| [Views, filters, and layout](/triage/views-and-filters) | How do I get to just the pull requests I care about? |
| [Actions on a pull request](/triage/actions)            | What can I do from here without opening GitHub?      |
| [Triage in Slack](/triage/slack)                        | How do I get the queue to come to me?                |
| [Troubleshooting Triage](/triage/troubleshooting)       | Why is it empty, stale, or refusing?                 |

## What's next

<CardGroup cols={1}>
  <Card title="Cards and signals" href="/triage/cards" icon="id-card" horizontal>
    Read every field on a card, from its next action and review state down to blast radius and review effort.
  </Card>

  <Card title="Change Stack" href="/change-stack" icon="layers-3" horizontal>
    Inspect a pull request as logical cohorts and layers after opening it from Triage.
  </Card>

  <Card title="How Triage prioritizes" href="/triage/prioritization" icon="list-ordered" horizontal>
    Understand the evidence behind a priority, and override it when you know better.
  </Card>
</CardGroup>