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

# Usage

> Review CodeRabbit Agent for Slack activity across your workspace, including when runs happened, which scope handled them, how many agent minutes they used, and where to inspect each thread.

export const Hint = ({type, children, headline, tip, href, cta}) => {
  const TIPS = {
    learnings: {
      headline: "Learnings",
      tip: "Review preferences CodeRabbit learns from your chat conversations and applies automatically to future reviews.",
      cta: "Learn about Learnings",
      href: "/knowledge-base/learnings",
      content: "Learnings"
    },
    walkthrough: {
      headline: "PR Walkthrough",
      tip: "A structured comment posted by CodeRabbit at the top of every pull request, summarizing changes, sequence diagrams, review effort, and more.",
      cta: "Learn about PR Walkthroughs",
      href: "/pr-reviews/walkthroughs",
      content: "Walkthrough"
    },
    "finishing-touches": {
      headline: "Finishing Touches",
      tip: "Post-review agentic actions (Autofix, writing docstrings or unit tests, and more) you trigger from a PR comment or a checkbox in the Walkthrough.",
      cta: "See all Finishing Touches",
      href: "/finishing-touches",
      content: "Finishing Touches"
    },
    "coding-plan": {
      headline: "Coding Plan",
      tip: "A detailed, codebase-aware implementation plan CodeRabbit generates from an issue or description, ready to hand off to any coding agent.",
      cta: "Learn about Coding Plans",
      href: "/plan",
      content: "Coding Plan"
    },
    "knowledge-base": {
      headline: "Knowledge Base",
      tip: "The collected context sources CodeRabbit draws on during reviews: Learnings, Code Guidelines, issue trackers, connected MCP servers, and cross-repo analysis.",
      cta: "Explore the Knowledge Base",
      href: "/knowledge-base",
      content: "Knowledge Base"
    },
    "path-instructions": {
      headline: "Path Instructions",
      tip: "Custom review rules that only apply to files matching a glob pattern, e.g. 'src/controllers/**'.",
      cta: "Configure path instructions",
      href: "/configuration/path-instructions",
      content: "Path Instructions"
    },
    scope: {
      headline: "Scope",
      tip: "A named set of repositories, connections, and spend limits that controls what CodeRabbit Agent can access in a given Slack conversation.",
      cta: "Learn about Scopes",
      href: "/slack-agent/scopes",
      content: "Scope"
    }
  };
  const defaults = TIPS[type] || ({});
  return <Tooltip headline={headline ?? defaults.headline} tip={tip ?? defaults.tip} cta={cta ?? defaults.cta} href={href ?? defaults.href}>
      {children ?? defaults.content}
    </Tooltip>;
};

**Know what CodeRabbit Agent for Slack has been doing across your workspace.** The Usage view answers the questions that matter after rollout: what ran, when, who triggered it, which <Hint type="scope">scope</Hint> handled it, how much runtime it used, and where to dig deeper.

## Who can see usage

Usage visibility depends on role:

| Viewer       | What they can see                                                  |
| ------------ | ------------------------------------------------------------------ |
| Global admin | All workspace activity                                             |
| Scope admin  | Activity for the scopes they manage, plus their own runs elsewhere |
| Member       | Their own runs only                                                |

## What the table shows

| Column        | What it shows                                                                                   | Example                         |
| ------------- | ----------------------------------------------------------------------------------------------- | ------------------------------- |
| Run At        | When the CodeRabbit Agent run happened, shown in your browser's timezone with UTC as a fallback | `Apr 3, 2025 2:22 PM`           |
| Agent minutes | How long the run spent working, shown in minutes                                                | `3.1`                           |
| Scope         | The resolved scope name for that run                                                            | `Base Scope` or `frontend-team` |
| Triggered By  | The Slack user who started it                                                                   | `@jane`                         |
| Thread        | Links to the original Slack conversation and the thread review UI                               | Slack link + review link        |

## What agent minutes mean

Agent minutes are the runtime unit CodeRabbit Agent uses for usage tracking and billing. For each run, CodeRabbit measures how long the run spent working in the sandbox, stores that time in seconds, and shows it in the UI as minutes.

This is a runtime metric, not a token metric. It reflects the duration of the Agent run while work is in progress, so it is easier to understand and closer to how CodeRabbit Agent usage is governed in the product.

In practice:

* Short runs use fewer agent minutes than long runs.
* Automation runs and human-triggered runs are measured the same way.
* Values can be fractional because the underlying runtime is recorded in seconds and then converted to minutes for display.

## Human vs. automation runs

Usage shows both human-triggered and automation-triggered runs in the same view:

* **Human runs** appear when someone mentions `@coderabbit`, uses a slash command, or sends CodeRabbit Agent a direct message.
* **Automation runs** appear either on their configured schedule or when a matching message triggers them. They show the automation name and the channel where they ran.

Both types resolve to a scope the same way. Filtering by scope is the fastest way to narrow down what you are looking for, and filtering by agent minutes helps you spot unusually short or unusually long runs.

## Common actions from Usage

From the Usage view, teams can:

* Open the related [thread review](/slack-agent/thread-reviews) for full run detail
* Jump back to the original Slack conversation
* Confirm which scope handled a request
* Review recent workspace activity without searching Slack first
* Trace an unexpected result back to its scope, triggering user, and execution detail

## Filtering and navigation

The Usage view supports text search across scope names and triggering users, scope-based filtering to focus on a specific team or channel, agent-minute filtering for minimum and maximum runtime, and sorting by time, agent minutes, scope, or user. Results are paginated so you can browse recent and historical runs without loading everything at once.

## What's next

<CardGroup cols={1}>
  <Card title="Thread reviews" href="/slack-agent/thread-reviews" icon="file-search" horizontal>
    Open a run in detail when you need to inspect context, diffs, and execution history.
  </Card>

  <Card title="Admin roles and security" href="/slack-agent/admin-and-security" icon="lock" horizontal>
    Review how activity visibility changes for global admins, scope admins, and individual members.
  </Card>

  <Card title="Automations" href="/slack-agent/automations" icon="repeat" horizontal>
    Use activity history to understand how scheduled and message-triggered CodeRabbit Agent automations are behaving after rollout.
  </Card>
</CardGroup>
