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

# Ask about the change

> Ask questions about the change you are reviewing in a conversation pinned to its review snapshot.

export const EarlyAccessBadge = ({tip = "This feature is in early access. Enable it by setting `early_access: true` in your `.coderabbit.yaml`, or by toggling Early Access on the web interface.", title = "Early Access", cta = "View configuration", href = "/reference/configuration#param-early-access", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="flask-conical" 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 AzureBadge = ({tip = "This feature is available on Azure DevOps.", title = "Azure", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="microsoft" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const BitbucketBadge = ({tip = "This feature is available on Bitbucket.", title = "Bitbucket", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="bitbucket" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const GitLabBadge = ({tip = "This feature is available on GitLab.", title = "GitLab", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="gitlab" 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 /> <GitLabBadge /> <BitbucketBadge tip="On Bitbucket, a chat answer cannot draw on repository inspection." /> <AzureBadge disabled tip="Azure DevOps artifacts are read-only, and chat requires write access on the pull request." /> | <TeamPlanBadge tip="Change Stack chat is available on the Team plan and above." /> <EarlyAccessBadge title="Preview" tip="Change Stack is in preview and still changing." />

Change Stack chat lets you ask questions about the change in front of you — why a function was touched, what a finding is really claiming, what else in the repository looks like this — in a conversation pinned to the review snapshot you are reading.

Chat needs two things: your organization on the **Team [plan](/management/plans) or above**, and **write access to the pull request**. Read-only access is not enough, which is also why chat is not offered on Azure DevOps, where every artifact is read-only.

## A thread stays on the snapshot it began on

<Warning>
  A chat thread stays pinned to the review run and commit where it began. It does not follow later snapshots.
</Warning>

This is the one thing to internalize about chat. If you opened a thread on Monday's snapshot and three more commits have landed since, that thread keeps answering about Monday's snapshot — its answers are not wrong, they are about an older state of the change. When a new snapshot arrives and you want answers about it, start a new thread. See [snapshots](/change-stack/snapshots) for how snapshots are created and selected.

## Where chat lives

The right panel shows either review context — summaries, comments, and the context for the range you have selected — or chat. [Navigate a change](/change-stack/navigation) covers the panel layout.

Opening chat shows **Chats**, a list of the conversations you have already had on this pull request. Pick one to carry it on, or start a new one. From inside a conversation, **All Conversations** takes you back to the list — which matters more than it sounds, because threads are pinned and you will accumulate several across a long-running review.

## Watching an answer being produced

While an answer is being written, chat shows the work it is doing as a trace. Each step is one of three kinds:

| Trace step                    | What it means                                                    |
| ----------------------------- | ---------------------------------------------------------------- |
| Inspecting repository content | The answer is reading code in the repository                     |
| Searching connected resources | The answer is searching resources connected to your organization |
| Searching the web             | The answer is searching the web                                  |

Each step is active, complete, or in error, so you can watch progress and see which steps failed rather than inferring it from a thin answer.

Read the trace rather than only watching it finish. An answer grounded in repository inspection and an answer assembled from a web search deserve different amounts of trust, and the trace is how you tell them apart before you act on what it says.

## Dictate a question

The composer has a microphone button. Record a question by voice and CodeRabbit transcribes it into the message box, where you can edit it before sending. It is available on both a reply and a new thread.

## Message states and stopping a generation

A message is generating, complete, stopped, or in error. You can stop a generation in progress, which leaves the message marked stopped rather than complete — useful when the answer has already gone somewhere you did not mean to send it.

## One generation at a time

A thread accepts only one active assistant generation at a time, so you cannot stack questions and read the answers later; ask, then ask again.

If a generation goes stale — the answer never lands and the thread looks stuck — it is cleared once it is more than 10 minutes old, but not by a timer. The cleanup runs when the thread is next opened or when you next submit a message, so reopen the thread or send the question again: the stuck generation is marked failed and the thread unblocks. Waiting on its own will not do it.

## Acting on an answer

When a coding action is offered in the conversation, you can start it from there instead of returning to the finding it came from. [Reviewing](/change-stack/reviewing) owns Coding Agent task offers and the conditions under which they appear.

## What chat does not do

Threads are listed and can be reopened, but there is nothing to archive, rename, or otherwise tidy them with. Chat also does not dispatch repository inspection through a Bitbucket provider client, so on Bitbucket an answer cannot draw on inspecting repository content — the other trace kinds are unaffected. [Provider support](/change-stack/provider-support) collects the per-provider gaps.

## What's next

<CardGroup cols={1}>
  <Card title="Snapshots" href="/change-stack/snapshots" icon="camera" horizontal>
    Understand what a snapshot is and when to move to a newer one.
  </Card>

  <Card title="Review and merge" href="/change-stack/reviewing" icon="message-square-code" horizontal>
    Turn what you learned into comments, a submitted review, or a coding task.
  </Card>
</CardGroup>