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

# Deliver a task's changes

> How accepted work from a CodeRabbit coding task reaches your repository: the two delivery modes, who pushes, what happens when delivery is blocked, and how to resolve delivery conflicts.

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

Delivery is always a separate, explicit step. A task that finishes successfully has changed nothing in your repository until you accept its patch and choose how it should land.

## Choose how changes land

A finished task rests in the **proposed patch** state: the work exists on the task page and nowhere else. That state is where you review, and it is not itself a way of delivering — leaving it is the delivery.

There are two ways to leave it:

| Mode                                  | What happens                                                                                               | Use it when                                                           |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| **Commit to the pull request branch** | The accepted patch is committed directly onto the working branch of the pull request the task is bound to. | The change belongs to the pull request under review.                  |
| **Stacked pull request**              | The accepted patch is pushed to a new branch and opened as a pull request against the working branch.      | You want the change reviewed on its own, or direct commit is blocked. |

You can reject a proposed patch at any point before delivery. After delivery, the changes are ordinary Git history — undo them through your provider the way you would undo any other commit.

<Info>
  Delivery from the standalone Coding Agent app covers GitHub, GitLab, Azure DevOps, and Bitbucket Cloud. Delivery from the embedded [Change Stack](/pr-reviews/change-stack) panel covers GitHub and GitLab.
</Info>

## Who pushes, and who wrote it

Delivery uses **your** Git provider authorization, and the commit carries CodeRabbit as its author.

That split is deliberate, and it has two consequences worth knowing:

* **Your permissions apply.** The push is made with your provider credentials, so branch protections and your repository permissions evaluate exactly as they would for a push you made by hand. Coding Agent has no path around them.
* **The change is attributable.** The commit is visibly CodeRabbit-authored, so it is obvious in `git log` and in review which changes came from an agent.

A stacked pull request is opened as you.

<Warning>
  Delivery needs a valid provider authorization for your own account, even though CodeRabbit authors the commit. If yours has expired or been revoked, delivery is refused — reauthorize your provider account and start delivery again.
</Warning>

## When delivery is blocked

Delivery can be refused after the patch is ready. Each refusal has a specific cause and a specific way forward.

| What happened                                      | What to do                                                                                                                                   |
| -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| The target branch no longer exists.                | Recreate the branch, or point the task at a branch that exists, and deliver again.                                                           |
| Branch protection refused the write.               | Deliver as a stacked pull request instead, use an allowed branch, or change the branch protection policy.                                    |
| The branch tip moved after the patch was built.    | Deliver as a stacked pull request. The patch was built against a commit that is no longer the tip, so committing directly is no longer safe. |
| Your provider authorization is missing or expired. | Reauthorize the provider account and retry.                                                                                                  |
| Conflict resolution rewrote the branch history.    | CodeRabbit declines to publish a merge commit on top of rewritten history. There is no in-product way past this one.                         |

A moved branch tip is not the same thing as a conflict. The tip check is about *when* the patch was built; a conflict is about *what* changed underneath it. The first is fixed by choosing a different delivery mode, the second by reconciling.

## Resolve delivery conflicts

Delivery can discover that the target branch has moved on since the task started. When that happens the task reports conflicts rather than forcing a write.

<Steps>
  <Step title="Conflicts are detected">
    Delivery stops and the task moves to a conflicted state. Nothing has been pushed.
  </Step>

  <Step title="Ask the task to reconcile">
    The task re-reads the current state of the branch, works out a resolution with the context it already has, and retries delivery.
  </Step>

  <Step title="Review the result">
    Reconciliation is a normal turn: it produces work you review the same way you reviewed the original patch.
  </Step>
</Steps>

Automated conflict handling covers up to **500 conflicted files**.

Conflict resolution can rewrite the task's branch history. When it does, CodeRabbit declines to publish a merge commit on top of that rewritten history rather than producing a misleading one.

## After delivery

If a task was started within an existing pull request, CodeRabbit posts a comment back on the pull request when it finishes. The comment links to the task, so anyone reading the pull request can open the full activity, diff, and decision history behind the change.

On GitHub and GitLab that comment carries interactive checkboxes for the follow-up actions. On other providers the same actions are offered as reply instructions in the comment itself. For the reply commands themselves, see [Review commands](/reference/review-commands).

The task page tracks the state of any pull request it opened — open, merged, or closed — so you can see from the task whether its work has landed.

## What's next

<CardGroup cols={1}>
  <Card title="Access and billing" href="/code/access-and-billing" icon="credit-card" horizontal>
    Which turns are free, how agent minutes are metered, and what the monthly cap does.
  </Card>

  <Card title="Coding environments" href="/code/environments" icon="container" horizontal>
    Give your repositories a reusable sandbox with the right toolchains, packages, and setup.
  </Card>

  <Card title="Work with a running task" href="/code/work-with-a-task" icon="activity" horizontal>
    Steer a task, answer its questions, and review its plan or patch.
  </Card>
</CardGroup>