Worktrees Arrive Just as Agents Need Them
GitHub Desktop 3.6, released on June 26, adds native support for Git worktrees, a feature that lets developers work across multiple branches at once without stashing changes or maintaining separate clones. On its own, worktree support in a graphical Git client is a sensible quality-of-life improvement that power users have wanted for years. In the context of mid-2026, it is something more pointed: an explicit accommodation for the way coding agents have changed the shape of everyday development. The timing is not coincidental.
GitHub frames worktrees as especially useful with coding agents that spin up isolated parallel sessions, and that framing reflects how the workflow has shifted. When a developer delegates several tasks to agents that each work on their own branch, juggling those parallel streams through the old stash-and-switch dance becomes painful. Worktrees let each branch live in its own working directory simultaneously, so an agent can churn on one task while the developer reviews another, with no conflict over a single working tree. The feature meets a real pain point created by the agentic turn in software development.
A Shared Copilot SDK Foundation
Beneath the headline feature, 3.6 introduces a Copilot SDK foundation that is shared across the client's AI capabilities, currently commit message generation and merge conflict resolution. Building these features on a common SDK rather than as one-off integrations is the kind of architectural decision that pays off later. It standardizes how the client talks to models, makes it easier to add new AI-assisted features, and, critically, enables consistent model flexibility across everything Copilot touches inside the app. That foundation is arguably more significant than any single feature it currently powers.
The practical expression of that flexibility is a model picker that lets users choose from available GitHub models for all Copilot features, alongside bring-your-own-key support for third-party or local models. The inclusion of bring-your-own-key is the detail enterprise teams will notice. It means an organization can route Desktop's AI features through its own model endpoints, including private or local models, rather than being locked to a single hosted option. That addresses data-governance concerns and gives teams control over cost and model choice, both of which have become live issues as AI usage scales.
AI Inside the Merge Conflict
The most genuinely useful new capability for day-to-day work is AI-assisted merge conflict resolution. Merge conflicts are a perennial source of friction and the place where less experienced developers most often make mistakes, blindly accepting one side or clumsily stitching the two together. The new feature can explain the conflicting changes and suggest resolutions that the developer can review, accept or edit. GitHub's own framing is that merge conflicts are now easier to navigate with AI-assisted resolution, and the emphasis on review-accept-edit is the right posture.
What makes this implementation sensible is that it keeps the human in the loop rather than auto-resolving conflicts silently. Explaining why two changes conflict is often the hardest part of resolving them, particularly when the conflicting code touches unfamiliar parts of the codebase. Surfacing that explanation and proposing a resolution, while leaving the final decision to the developer, turns a frustrating manual chore into a guided one without surrendering control. It is a good example of AI assistance done well: reducing cognitive load on a genuinely hard task while preserving the human's authority over the outcome.
Reading the Project's Own Conventions
A quieter but important refinement is that Copilot-powered commit authoring now reads custom instructions from a repository's copilot-instructions.md and AGENTS.md files, honoring the project's commit metadata rules. This is the kind of integration that separates a toy AI feature from a usable one. Generic AI-generated commit messages tend to be bland or inconsistent with a team's conventions, which is why many developers ignore them. By reading the project's own instruction files, the client can generate commit messages that actually follow the established style and metadata requirements.
The convergence around AGENTS.md as a shared convention is worth noting in its own right. That file has emerged as a common place to encode instructions for AI tools working in a repository, and GitHub Desktop honoring it alongside its own copilot-instructions.md format signals that these conventions are stabilizing across the ecosystem. For teams, the payoff is consistency: the same instruction files that guide coding agents now also guide commit message generation, so the AI's output respects the team's standards regardless of which tool is producing it. Small as it sounds, this kind of convention-awareness is what makes AI features stick.
The Desktop Client Catches Up to the Agent Era
Taken together, the 3.6 release reads as GitHub Desktop adapting to a development world that looks meaningfully different than it did even a year ago. Worktrees for parallel agent sessions, a unified Copilot SDK, model choice with bring-your-own-key, and convention-aware AI features all point in the same direction: the graphical Git client is being retooled around the assumption that developers now work alongside agents and across many parallel branches. That assumption was not safe to make eighteen months ago. It is now.
For teams that favor a graphical client over the command line, these are substantive improvements rather than cosmetic ones, and the bring-your-own-key support in particular makes the client more viable in governed enterprise environments. The broader signal is that the everyday tooling of software development is being rebuilt around AI and parallelism as defaults, not add-ons. GitHub Desktop is not the most advanced surface for that shift, but its evolution is a reliable indicator of where mainstream development workflows are heading, because it serves the developers who are not living on the bleeding edge.
What It Means for Engineering Teams
Engineering leaders should read this release less as a list of features and more as confirmation of a workflow change worth planning around. If your developers are increasingly delegating work to coding agents, the friction of managing parallel branches is real and growing, and tooling that natively supports worktrees removes a concrete source of that friction. Standardizing on conventions like AGENTS.md across your repositories pays off as more tools learn to read them, producing consistent AI behavior whether the work is done by a person or an agent.
The model-flexibility story is the part to evaluate most carefully. Bring-your-own-key and model selection are how organizations retain control over data, cost and model choice as AI features proliferate across the development toolchain. Teams that have standardized on private or local model endpoints for governance reasons can now extend that standard into the Git client itself rather than treating it as an exception. As AI seeps into every layer of the development experience, the ability to point those features at endpoints you control, rather than accepting whatever a vendor defaults to, is becoming a requirement rather than a luxury.
