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

# Work with a running task

> Follow a CodeRabbit coding task while it runs: watch its activity and live diff, steer it, answer its questions, review its plan, and review the patch it proposes.

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 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 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 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 /> <AzureBadge title="Azure DevOps" /> <BitbucketBadge title="Bitbucket Cloud" /> | <OpenBetaBadge tip="Coding Agent is in beta." />

## Overview

Every task, whatever started it, has a task page. The page is where you watch the work, interrupt it, answer it, and decide what to do with what it produced. It has its own address, so you can close it and come back, or send the link to someone else on your team.

## Follow the work

The task page shows the current state of the run alongside three live views.

| State                                   | What it means                                                                                                |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| Queued, preparing                       | Waiting for capacity, or building the sandbox.                                                               |
| Running, revising                       | A turn is executing.                                                                                         |
| Plan ready, patch ready                 | Something is waiting for your review.                                                                        |
| Resolving conflicts, conflicts detected | Delivery hit a conflict. See [Resolve delivery conflicts](/code/deliver-changes#resolve-delivery-conflicts). |
| Completed, no file changes              | The run finished — in the second case without changing any files.                                            |
| Failed, canceled, rejected              | The run ended without delivered work.                                                                        |
| Stale                                   | The task no longer matches the branch context it was created against.                                        |

**Activity.** A running feed of what the agent is doing, grouped by kind:

| Activity | What it covers                  |
| -------- | ------------------------------- |
| Read     | Reading repository content.     |
| Search   | Searching repository content.   |
| Edit     | A file edit.                    |
| Command  | A shell command and its result. |
| Tool     | Another tool invocation.        |
| Web      | Web retrieval or browsing.      |
| Task     | A task-management action.       |
| Status   | A run-status update.            |

When you reopen a task that is still running, the page replays its recent activity: up to 200 events from the last 15 minutes.

**Live diff.** The changes made so far, updating as the agent works. You don't have to wait for the task to finish to see where it's going.

**Presence.** Who else is looking at the task right now, so two people don't steer it in opposite directions.

<Info>
  A task link can point at a task in a different organization from the one you have selected. CodeRabbit resolves the owning organization and switches your context when you have access to it.
</Info>

## Inspect the workspace

The task works in a prepared, isolated checkout of your repository. You can look inside it:

* **Files** — browse the checkout the agent is working in, and reference files back to it in your next message.
* **Command output** — the work the agent did at the terminal, surfaced in the activity feed.
* **Browser** — when the task runs something with a web interface, open its viewer and navigate it yourself. Viewer activity keeps the session alive while you're using it.

A task's workspace stays available while it is active, which lasts about a week without use, and its snapshot is retained for 30 days.

## Steer the task

You do not have to wait for a turn to end to change its direction.

| Action                              | When to use it                                                                                          |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------- |
| **Steer**                           | Send an instruction to the running turn immediately — a correction, a constraint, a change of approach. |
| **Queue a message**                 | Add an instruction for the agent to pick up when the current turn finishes.                             |
| **Edit or delete a queued message** | Change your mind before the agent gets there.                                                           |
| **Promote a queued message**        | Move a queued message to the front so it becomes the next instruction.                                  |

Queued messages are ordinary follow-up turns, so normal billing applies to them. See [Access and billing](/code/access-and-billing).

## Answer a question

When the agent needs something only you know — which of two behaviors is intended, whether a migration is safe — it raises the question on the task page and waits. Answer it there and the run continues with your answer as context.

## Review a plan

In plan mode the agent writes an implementation plan and stops. Plans are versioned, so a revision supersedes the previous one rather than editing it in place.

You have three responses:

| Response    | What happens                                                                                                            |
| ----------- | ----------------------------------------------------------------------------------------------------------------------- |
| **Approve** | The plan is accepted. You can then switch the task to code mode and have the agent implement exactly the approved plan. |
| **Discuss** | Keep talking about the plan without replacing it.                                                                       |
| **Revise**  | Submit your feedback as a request for a new version of the plan.                                                        |

<Warning>
  The author of a plan can't approve that same plan. Another eligible member of your organization has to approve it, so an implementation always passes a second pair of eyes.
</Warning>

A Coding Agent plan is not the same thing as a [Coding Plan](/plan/index), which is CodeRabbit's separate planning product. A Coding Agent plan lives inside one task and gates that task's implementation.

## Review the proposed patch

By default a finished task produces a **proposed patch** rather than pushing anything.

* **Read the diff**, in full or as it was being built.
* **Comment on a line**, on either side of the diff — the new-file side for something the agent added, the old-file side for something it removed.
* **Request a revision**, and the agent produces a new proposal.
* **Reject the proposal** if the approach is wrong.
* **Accept it** and choose how it lands. See [Deliver a task's changes](/code/deliver-changes).

## Address CodeRabbit's review comments

<GitHubBadge />

Once a task's changes are on a pull request and CodeRabbit has reviewed them, unresolved CodeRabbit findings can go straight back to the same task. It collects the open review comments and runs a follow-up turn against them, keeping all the context it already has instead of starting over.

## Stop a task

Cancel a running task from its page. Cancellation stops the current turn; the task, its history, and anything it already delivered remain.

## Find your tasks

Your organization's tasks are listed at [app.coderabbit.ai/code/tasks](https://app.coderabbit.ai/code/tasks), grouped by what they need from you: tasks that are working, tasks waiting on a person's decision or input, tasks that completed, and tasks that failed.

Filter the list by what started each task: **Chat**, **Finishing touch**, **Issue Plan**, **Prompt**, **Merge conflict**, **CR comment**, or **Security fix**.

**Archive** an idle task to take it out of the ordinary list. Archiving is a visibility marker only — it doesn't change whether the task completed or failed, and it can't be applied to a task with a turn in progress. Include archived tasks in the filter to see them again, or unarchive one to return it to the list unchanged.

## Control who can see a task

A task is visible to your team by default. Switch it to **private** and its prompts, files, activity, and attachments become visible only to you — including to anyone following a direct link to it.

Only the task's author can change this, and it can be changed back at any time. To create a task private from the start, use the `/private` slash command in the composer.

## What's next

<CardGroup cols={1}>
  <Card title="Deliver a task's changes" href="/code/deliver-changes" icon="git-pull-request" horizontal>
    Choose how accepted changes land, and what to do when delivery is blocked.
  </Card>

  <Card title="Access and billing" href="/code/access-and-billing" icon="credit-card" horizontal>
    Understand which turns are free, how agent minutes are metered, and how the monthly cap behaves.
  </Card>

  <Card title="Start a coding task" href="/code/start-a-task" icon="play" horizontal>
    Every way to start a task and where each one is available.
  </Card>
</CardGroup>