Azure Repos ships in two editions and they do not have the same AI review options. Copilot code review runs on Azure DevOps Services, where Microsoft now labels it a public preview, and it stops there. Azure DevOps Server has no Microsoft-native AI reviewer, so a server team runs PR-Agent from a pipeline, wires a vendor webhook into Service Hooks, or self-hosts something. The edition decides the setup work, the permissions, and how a reviewer learns your coding standards.
Copilot code review is Azure DevOps Services only
The get started page is headed Azure DevOps Services, and the feature now carries a public preview label. That wording changed from the limited preview phrasing the page used earlier, and the change is worth tracking if you are planning a rollout, because preview features can still be altered or withdrawn. If you are comparing this against other forges, Copilot code review availability by edition covers where the feature runs outside Azure Repos.
The prerequisites are an Azure DevOps organization and a Git repository in Azure Repos (TFVC is not supported), plus an Azure subscription linked to the organization, because usage is billed through Azure Cost Management rather than through seats.
Enablement cascades. A Project Collection Administrator turns the feature on at the organization level under Organization settings > Repos > Repositories, and the Enable all option there covers every project and repository at once. A Project Administrator can then scope it to individual projects, and a repository owner turns it on per repository when project settings allow overrides. Individual users opt in through Preview features unless an administrator has enabled the preview for everyone in the organization.
Verifying it took effect is a one-step check: open any pull request in the repository and GitHub Copilot should appear as an available reviewer in the Reviewers list.
Two settings decide how the feature behaves day to day, and they are independent of enablement. Automatic reviews require a branch policy on each target branch where you want Copilot to review pull requests. Without that policy, Copilot is available but somebody has to add it as a reviewer by hand. How that policy interacts with required status checks is a separate problem, and merge gating for AI reviewers on Azure Repos covers the failure modes.
The other setting is the review effort. A project administrator sets the default for the project and decides whether repository administrators may override it; when overrides are allowed, a repository admin sets a different default per repository, and if the project forbids overrides that field is read-only and shows the inherited value. Users can also pick a different effort for a single review without changing either default. Higher effort generally consumes more tokens, which increases cost. One thing to watch when you write internal runbooks: the settings screenshots on the page show Medium as an inherited default and Balanced as a selectable option, so the effort names in the UI are not settled enough to hard-code into documentation.
For a team on Azure DevOps Server, none of that applies.
How Copilot reads your team’s rules, and the target-branch catch
Copilot code review takes instructions at the organization and project level through Azure DevOps settings, and at the repository level through a file. The instructions page accepts two paths for that file, .github/copilot-instructions.md or .azuredevops/copilot-instructions.md, both at the repository root. The second path is worth noticing if your team already keeps GitHub Copilot instructions under .github/, because either location works here.
Path-scoped files go in .github/instructions/ or .azuredevops/instructions/ as *.instructions.md, with YAML front matter carrying an applyTo value. Copilot applies those rules only to changed files matching the pattern, and a path-scoped file without applyTo is skipped. That is a quiet failure mode: the file is committed, nothing reviews against it, and nothing reports an error.
Precedence is documented, with a caveat that matters. When instructions overlap, Copilot applies repository-level instructions first, then project-level, then organization-level, and the higher-precedence scope wins a conflict. The same page then notes that this order guides review behavior but is not guaranteed, because the model can occasionally interpret or apply conflicting instructions differently. Treat the ordering as a design intent rather than a hard override, and avoid shipping directly contradictory rules at two scopes in the first place.
The catch that changes rollout is which branch the instructions come from. Repository-level and path-scoped files are read from the pull request’s target branch only. A pull request that adds or edits the instructions file is not reviewed against the new text; those rules apply once the change is merged into the target branch. If you are rolling out standards, land the instructions file on the default branch first so later pull requests pick it up.
What runs on Azure DevOps Server instead
On the server edition the choice is between self-hosted tools and hosted vendors that reach into your instance.
PR-Agent lists Azure DevOps as a supported git provider, and the support matrix lists an Azure DevOps pipeline as supported usage, so a Server team can run it as a pipeline job or behind a webhook. It is community-owned and MIT licensed, and the repository describes the deployment shapes it supports (CLI, Docker, self-hosted webhooks) plus per-provider setup guides. Review categories and prompts live in configuration files you own, and the matrix lists repo context files such as AGENTS.md. That combination is what makes it the default starting point for a Server team that wants review output posted on the pull request, and the pipeline, branch policy and webhook routes for Azure Repos are worth reading before you pick one.
Open Code Review from Alibaba is a different shape. It installs from npm as ocr, works on a git diff, a commit range, or a whole-file scan, and needs an LLM endpoint rather than a forge integration. On a firewalled Server install that is convenient, and it also means the tool does not post comments to a pull request by itself unless you wire that up. Its published benchmark is the project’s own, built from 50 repositories, 200 pull requests and engineer-annotated issues, and it reports higher precision than a general-purpose agent on the same model at roughly a ninth of the tokens, with lower recall as a stated trade-off.
Hosted vendors document this edition less clearly. CodeRabbit’s Azure DevOps page covers a PAT or a Microsoft Entra service principal, Project Administrator or Project Collection Administrator rights, and the Edit Subscriptions permission on Service Hooks so the webhook can be installed. The page notes that permission cannot currently be granted through the UI, and it is granted per project, which is a real constraint across a large organization. It does not split Azure DevOps Services from Azure DevOps Server, so it does not establish Server support on its own.
Qodo’s on-premises Azure DevOps guide deserves a close read for the same reason. It walks through a Microsoft Entra app registration, a service account added to the Azure DevOps organization with Basic access and Project Administrators, and a Service Hooks webhook subscribed to PR Created, PR Updated, PR Commented and PR Merged. The steps assume dev.azure.com and Entra ID, which are Azure DevOps Services constructs, while the deployment matrix marks on-prem as unsupported for Azure DevOps Cloud. Read together, the guide covers running Qodo on-premises against Azure DevOps Services. It does not document an Azure DevOps Server install, so treat the matrix row and the install guide as answering different questions.
Kodus connects to Azure DevOps with a token; its quickstart documents no OAuth path for that provider, unlike GitHub and GitLab. The same page covers the Server case directly, since a self-hosted Azure DevOps Server instance needs Kodus’s IP 52.55.217.197 allowlisted so the service can reach it. Rules come from Kody Rules in the product plus the repository files Kodus detects, and the rule file detection docs list .github/copilot-instructions.md and .github/instructions/**/*.instructions.md among the supported patterns, not the .azuredevops/ paths. A team that standardizes on .azuredevops/ instructions will have to duplicate them into .github/ for Kodus to read them. On the free self-hosted Community edition the limits matter for a rules-heavy setup: an unlicensed instance evaluates at most 10 rules per review, oldest first, and the pricing page caps Community at 10 Kody Rules and 3 plugins.
Which routes follow your rules, by edition
| Route | Azure DevOps Services | Azure DevOps Server | How it learns your rules |
|---|---|---|---|
| Copilot code review | Yes, public preview, billed through an Azure subscription | No | Organization and project settings, .github/ or .azuredevops/ instruction files |
| PR-Agent | Yes, pipeline job or webhook | Yes, same self-hosted shapes | Config files you own, repo context files such as AGENTS.md |
| Open Code Review | Runs on a diff, not a forge integration | Same | Prompts and config you supply; needs an LLM endpoint |
| CodeRabbit | Yes, PAT or Entra service principal | Not established by the vendor page | Repository configuration; the page does not split editions |
| Qodo, on-premises | Yes per the on-prem guide (dev.azure.com and Entra ID) | Not documented; the matrix marks on-prem unsupported for Azure DevOps Cloud | Repository configuration |
| Kodus | Yes, token only | Yes; the instance IP must be allowlisted | Kody Rules plus detected files, .github/ paths only |
What the edition split actually costs you
The interesting part is not which tools exist on each edition. It is that the rules mechanism changes shape when you cross the line. On Services, Copilot reads instructions from Azure DevOps settings and from repository files, which means the organization can push standards down and a repository can override them, with a documented precedence order that the model is allowed to deviate from. On Server you are assembling that from tool config, and every tool reads a different set of files. Kodus reads .github/ paths but not .azuredevops/, PR-Agent reads AGENTS.md, and Open Code Review reads whatever you put in its own config.
That difference is the reason a Server team should pick its reviewer before it writes a single rule file. Standardizing on .azuredevops/instructions/ first and then discovering that your reviewer only reads .github/instructions/ leaves you maintaining two copies of the same policy, and the copies will drift. Pick the tool, read its file list, then write the instructions once.