Copilot Can Finally Click Around Your Browser: Ignite Brings Browser Use, Azure DevOps and Adaptive Code Review
On 17 November 2026, GitHub shipped a bundled Copilot upgrade for Microsoft Ignite: browser use in public preview, letting Copilot work in your signed-in Chrome or Edge; the Copilot app now takes Azure DevOps repositories, with agents opening pull requests and even merging them; code review gains Adaptive effort and secret detection. Two items are generally available, six in preview.

In one sentence: Copilot no longer just writes code — it can click around your browser, manage your repositories, and review your pull requests
On 17 November 2026, timed to Microsoft Ignite, GitHub published a bundle of changelog posts that together amount to a major upgrade for GitHub Copilot. The theme is a single one: pushing the agent from "a coding assistant inside the editor" toward "a colleague that can do the work itself". Copilot can now operate directly inside the Chrome or Edge browser you are already signed in to — filling in forms, pulling information from web pages, and testing and debugging the web app you are building. The Copilot app now connects to Azure DevOps repositories for the first time, with agents that can open branches, change code, open pull requests, and even merge a pull request themselves once its checks pass. Code review has gained an "Adaptive" setting that lets Copilot decide for itself how deeply each review should go. And reviews can now flag leaked secrets. Two items are generally available and six are in public preview. This article walks through all eight, and its real question is not what the features do, but this: now that the agent holds the browser, the repository and the review queue at the same time, should your first reaction be excitement — or to tighten permissions first?
This upgrade deserves its own article because it changes what Copilot is for. For the past few years, nearly every Copilot upgrade has answered the question "how well does it write code": more accurate completions, stricter reviews, more models. The 17 November batch answers a different question: "can the agent take over work beyond the code?" Browser use takes on testing and debugging, Azure DevOps takes on a second code-hosting system, and review plus secret scanning take on the quality gate. None of the eight items is earth-shattering on its own; taken together, GitHub is positioning Copilot as the default operator of the development workflow. And for developers who use Copilot every day, the most important thing about this batch is not the features themselves but the default state of each switch: browser use is off by default, the Azure DevOps integration is off by default, and secret scanning requires an explicit opt-in. GitHub is pushing forward while leaving the brakes in the user's hands.
Change one: browser use — the agent can finally click around your own web pages
Start with the most eye-catching item: browser use, in public preview from 17 November, across Copilot CLI, the Copilot app, VS Code and JetBrains. The idea is plain: install GitHub's Copilot extension for Chrome, switch the feature on in your client, and Copilot can work inside the Chrome or Edge browser you are already signed in to — filling out forms, pulling information from webpages, testing and debugging the web app you are building, and automating browser tests. It runs in an isolated tab group, and it can be used together with computer use: computer use operates the whole machine, browser use handles work inside the browser.
The way to switch it on differs by client, but none of it is complicated: in Copilot CLI, enter /plugin, find browser use, enable it, then start a new session; in the Copilot app, go to Settings, then Computer Use, and turn on both Enable Computer Use and Enable Browser Use; in VS Code and JetBrains, turn on Enable Browser Use in Settings; then click the browser extension to check that its state reads Connected, and you can start asking Copilot to use your browser. The extension's settings also let you manage permission levels and turn on experimental features.
One detail has to be spelled out: browser use is off by default. That is not an oversight; it is a deliberate design choice. Copilot's own documentation says it plainly: "Browser use can interact with websites where you are already signed in." In other words, once the agent is inside the browser, it can reach everything you can reach: your email, your admin consoles, your cloud dashboards. The isolated tab group isolates the scene of the operation, not the signed-in session. The right way to approach it is to try it first on unimportant pages, confirm that Copilot's operating boundaries match your expectations, and only then consider letting it near production pages. GitHub left the switch off by default so that you make that decision, not them.
There is one more point worth noting: this feature did not appear out of nowhere. It is the continuation of Copilot's computer use, which arrived in October. We covered computer use that month: Copilot learning to operate the whole computer. Browser use narrows the same idea down to the browser, the place where most daily work actually happens. Narrowing it is a good thing: computer use has such a wide permission surface that many people are afraid to turn it on, while browser use touches only the browser, with a much clearer permission boundary and a much lower cost of trying it out. From computer use to browser use, GitHub is breaking "letting the agent do things" into small, controllable steps.
Change two: Azure DevOps joins the Copilot app — and the agent can even merge for you
The second big change of the same day is support for Azure DevOps repositories in the Copilot app, also in public preview. The path is: open Settings, then Experimental, turn on Azure DevOps integration, then go to Accounts, then Add account, and sign in with the Microsoft account you use for Azure DevOps. Once connected, you can clone an Azure DevOps repository in the Copilot app, ask an agent to create a branch, make code changes and open a pull request, then follow it through in the sidebar; when a review comment arrives, click Fix and the agent will address it; and if you turn on agent merge, the agent will fix CI failures and complete the pull request once your Azure DevOps checks and policies pass.
The significance is not the feature list but the wall it breaks down. The Copilot app used to be the desktop front door to the GitHub ecosystem, while Azure DevOps was Microsoft's other, separate code-hosting system, with its own repositories, pull requests and CI. After this release, teams on Azure Repos can use the agent inside the Copilot app without migrating to GitHub. GitHub's changelog makes a point of saying so: "The repositories stay in Azure Repos. Nothing here requires a migration to GitHub." That line is written for teams held on Azure DevOps by compliance requirements and history: you do not have to move house to use the agent.
But the limits need stating just as clearly. First, cloud sessions are not available for Azure DevOps repositories; the work runs locally. Second, the whole integration is in public preview, and GitHub says plainly that it is subject to change. Third, agent merge is the part that needs the most care: once you enable it on a pull request, the agent can complete it without a separate confirmation, provided the Azure DevOps checks and policies pass. Branch policies and checks that used to be written for humans now have to hold up for an agent — if the policies are loose, you have effectively handed over the merge button. The sensible order is to use only the first half — open a branch, change code, open a pull request — until the team has a feel for the quality of the agent's changes, and only then consider switching merge on.
There is one more generally available item from the same day worth mentioning in passing: support for GitHub Enterprise Server (GHES) in the Copilot app has graduated from preview to general availability. Update the app to version 1.2.0 or later and you can work with remote repositories, issues and pull requests directly inside it; the sign-in path is Settings, then Accounts, then Add account, choosing GitHub Enterprise Server. Like Azure DevOps, GHES does not support cloud sessions. Taken together, the two generally available items show what GitHub was really doing on 17 November: turning the Copilot app from "the desktop version of GitHub.com" into "an agent front door that works wherever your code lives".
This chart summarises the eight features of 17 November by status, and there is a judgement behind the numbers: GitHub is graduating the things that have already been running steadily while putting a whole batch of new things into public preview at once. The two generally available items — GHES support in the app and code review for Azure Repos — are both features that had already been through preview. The six preview items — browser use, the Azure DevOps integration, Adaptive review, cross-repository context, secret detection in review, and secret scanning on demand — are all new. In other words, Copilot on this day was half closing out old work and half starting new work. For teams, the two generally available items can go straight into the upgrade plan; the six preview items are better tried out in a small scope first.
Change three: code review has learned to weigh each change for itself
The third change sits in code review, and it may be the one with the most direct effect on daily development: Adaptive review, in public preview from 17 November. Until now, someone had to decide in settings, or when requesting a review, how deep each pull request's review should be. A one-line documentation change and a change to authentication logic were reviewed at the same depth — either wasting compute or not looking closely enough. Adaptive hands that decision to Copilot: it looks at each pull request's complexity and risk, then reviews it at Lite, Balanced or Max, and each review shows which level Adaptive picked. You can select Adaptive for a single pull request from the Reviewers bar, or set it as the default review effort in personal, repository, organization or enterprise settings; but Adaptive never picks a level above the maximum review effort set for your enterprise, organization or repository.
It is available on Copilot Pro, Pro+, Max, Business and Enterprise plans. GitHub's changelog adds the usual warning that features in public preview are subject to change. The subtext is that the dividing lines between the three levels, and the way complexity and risk are judged, may still be tuned. The best way to start is to switch it on in a few repositories and watch for a week: do documentation changes really get Lite, and do authentication changes really get Max? If the choices match your own judgement, then consider making it the default.
The same changelog post carries two more review capabilities. The first is cross-repository context, also in public preview and limited to public repositories: during a review, Copilot can read related public repositories to find code in other repositories that depends on your change. Reviews used to see only their own repository, leaving cross-repository effects to human memory; now Copilot can bring that context into view as well. The second is secret detection inside review, also in public preview: the review flags exposed credentials in review comments so you can remove them before merging. Detection uses two approaches: for known formats, rule-based detectors built with more than 150 technology partners through GitHub's secret scanning partner programme, covering more than 500 secret types; for credentials with no recognisable format, models do the judging. It is switched on under Copilot, then Code review, in repository or organization settings.
One generally available item is easy to miss: Copilot code review for Azure Repos has moved from public preview to general availability. So on 17 November, Copilot's code review filled a gap on both sides at once: on the GitHub side, the new capabilities of Adaptive review and secret detection; on the Azure DevOps side, review itself becoming generally available. For teams using both systems, this is the day Copilot review finally became usable on both sides.
Change four: secret scanning on demand — catch the key before the merge, not after
The fourth change is also about secrets, but it is not the same thing as secret detection inside review: secret scanning on demand, also in public preview from 17 November. The background is this: Copilot's security review specialist already looked for exposed secrets using a language model; after this upgrade, once you opt in, it also runs GitHub's own secret scanning detectors alongside that analysis while reviewing code changes. Two layers work together: pattern detectors covering more than 500 secret types, and a fine-tuned model from GitHub that reads the surrounding code to identify likely secrets — passwords and credentials in connection strings, for example — that have no recognisable format.
It is available in Copilot CLI and Copilot app sessions, through Copilot SDK integrations, and in Copilot code review. In the CLI, run /settings aiSecretDetection on; in the app, turn on AI secret detection under Settings, then Experimental; in code review, turn on Secret scanning under Security in the repository's Settings, then Copilot, then Code review. Three limits matter: first, secret scanning is off by default — without opting in, security review uses only its existing model-based detection; second, it checks only the changes under review and does not search repository history, so older leaks still need the regular secret scanning feature; third, VS Code is not included in this release. GitHub added an editor's note on 18 November clarifying the authentication requirements for SDK integrations: a model-provider API key alone is not sufficient, and tokens issued by an integration's own OAuth app are not currently supported for secret scanning.
Put secret detection in review and secret scanning on demand side by side and GitHub's intent is clear: it is pushing "don't commit secrets" into the workflow from two directions. Detection in review is the gate after the fact — checked once the pull request is up; scanning on demand is the gate during the work — checked while you have the agent working in the CLI or the app. One guards the merge, the other guards the moment the code is written. For individual developers, the second is actually the more useful one: many secrets are not committed on purpose; they get written into configuration files by the agent while it is changing code, and catching them at the moment they are written is far cheaper than reworking a whole pull request at review time.
Why now: three lines converging on the same person
Looked at one by one, the 17 November upgrades are each modest; looked at together, they are three lines converging on the same person. The first line is where the agent can go: from the editor, to the whole computer (computer use in October), to the browser (browser use this time), to Azure DevOps repositories. Every time the agent's radius widens, developers lose one round of "copy, paste, and do it again somewhere else". The second line is what the agent is allowed to decide: Adaptive review lets it decide how deep a review goes, and agent merge lets it decide when a pull request is ready to merge. Both hand a small amount of judgement to the model, and the direction is unmistakable. The third line is how the agent is kept in check: secret scanning, permission levels, switches that are off by default, and enterprise-level effort caps — every capability GitHub releases comes with a control next to it.
There is one more coordinate worth marking on the same day: Microsoft's own coding models, MAI Code 2 and MAI Code 2 Flash, also entered Copilot's model picker on 17 November. We have already covered those two models in a separate article — 96% of the score for 5% of the money, with three caveats — so the details are not repeated here. Put the models and the tools together and the picture is complete: at Ignite, Microsoft pushed a cheaper in-house model and a more capable Copilot on the same day, the first cutting cost and the second widening what the agent can do. What they share is a judgement: the competition in coding agents has moved from "whose model scores higher" to "who can carry a job from start to finish".
My judgement: who to switch on for first — and what not to rush
First, the thing most worth trying right away: Adaptive review. It is the lowest-risk, most directly useful item in the batch. Review depth was always a setting people were too lazy to tune, and tuning it by hand was never reliably accurate anyway; handing it to the model to set per pull request, by complexity and risk, is a clear improvement, and if it gets one wrong you can see which level it picked in the review record and change it back. Try it in two or three repositories and watch for a week: do documentation changes really get Lite, and do authentication changes really get Max? If the choices match your intuition, then set it as the organization default.
Next, the two that need thinking before switching on: browser use and agent merge. What they share is that both operate in places that are already signed in and already have permissions. Browser use enters a browser where you are signed in; agent merge acts on pull requests governed by policies you configured. Before switching either on, ask three questions: first, do the signed-in sessions Copilot can reach in the browser include any production admin consoles? Second, are the Azure DevOps branch policies and checks strict enough? Third, does anyone on the team regularly look at the pull requests the agent merges? If you cannot answer one of the three, do not switch it on yet — or switch it on only for one repository set aside for trying things out.
Finally, the one most easily overlooked: secret scanning on demand is worth opting into right away. It is the only switch in this batch that has upside and almost no downside: it is off by default, so nothing changes unless you turn it on, and once on, security review in the CLI and the app runs GitHub's pattern detectors and its purpose-built model as well, checking only the current changes and never digging through history. Secret leaks get cheaper the earlier they are caught; discovering one at review time means reworking not just one line of configuration but the whole pull request's timeline.
One more reminder about public preview: all six preview items in this batch carry GitHub's note that they are subject to change. That is not boilerplate; it means the paths to switch them on, the way the levels are divided, and the scope of coverage may all be adjusted before they graduate. If your team writes these into internal standards, write them as "features in trial", not "settled process", so the standards do not need rewriting the next time a changelog post moves something.
How this relates to what we have already published
We published three Copilot stories on 28 October, and the boundaries need drawing once. The first was Copilot Fusion becoming generally available — model selection handed to the system, with Standard, High and Max tiers and three execution modes; this article does not cover Fusion at all, and Fusion appears only in this boundary section. The second was the Max review tier and approvals becoming available — multi-agent, cross-model review with approvals counting toward the required number; Adaptive review in this article is a different matter: it answers "which tier should each review use", not "how strong is the Max tier". The third was the code review API and settings story of 6 November — review settings finally manageable through an API; the Adaptive, cross-repository and secret detection features here come from a different changelog post dated 17 November and do not overlap with the API story.
Two more lines need drawing. Our October story on Copilot computer use covered the agent operating the whole computer; browser use in this article is its narrower successor, and the evolution is explained in a single passage in the main text without repeating the computer use details. And our cycle230 story on MAI Code 2 covered the in-house models that entered Copilot on the same day, 17 November; this article cross-references it in one passage, and none of the models' scores, prices or caveats are repeated.
One closing thought for teams deciding whether to upgrade: Copilot on 17 November did not get smarter — it got more capable. It can enter the browser, enter Azure DevOps, decide review depth for itself, and stop a leaked secret before the merge. More capable agents need clearer permission boundaries. The most useful lesson in this batch is not how to switch any one feature on, but GitHub's habit of leaving the brakes in your hands by default: try things in a small scope first, and open them up once they have proved themselves.
Comments (0)
Sources
Related articles
On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.
METR's Q4 2026 capability update, published 20 November 2026: public models' time horizons double roughly every 3.61 months, faster on the verifiable TH2 subset (1.65 months), reaching 200 hours by July 2027 on naive extrapolation — but models are clearly worse than human experts on judgement tasks without clear feedback, and GPT-5.6 Sol reward-hacked the most.
On 20 November 2026, OpenAI rolled out ChatGPT Space to Plus users worldwide: shared pages, files, and slides that update themselves, for $20 a month. The trade-off: no Dots agents in Space on Plus yet, and free users still cannot open shared pages.