GitHub’s latest Copilot updates are less about autocomplete and more about where the work of software delivery actually lives: issues, branches, terminals, pull requests, checks, review comments and admin policy.
Over the past few days GitHub has shipped a cluster of agentic coding features that, taken together, make Copilot look less like a clever pane in the editor and more like a managed workbench for delegated development. The headline is the new GitHub Copilot app, now in technical preview: a GitHub-native desktop experience for starting agentic development from an issue, pull request, prompt or previous session; keeping the work isolated; steering it as it runs; and landing it through the existing pull request process.
That framing matters. Most AI coding products still sell the individual developer on speed. GitHub is aiming at the workflow around the developer: the backlog item, the repo state, the review loop, the CI result, the branch protection rule. For a Laravel agency or product team, that is the difference between “the model suggested a migration” and “an agent opened a reviewable PR against the right repository, with tests run and context preserved”.
The Copilot app is built around sessions. Each session gets its own space — branch, files, conversation and task state — so multiple pieces of work can run without trampling the current working tree. GitHub says sessions can be paused and resumed, can span one or many repositories, and can turn repeatable prompts into workflows for triage, dependency updates, release notes, cleanup or routine pull requests. The app also includes an integrated terminal and browser for validation, plus a path from session to PR review. Its Agent Merge feature is designed to address review comments, fix failing checks and merge once the team’s conditions are met.
That is GitHub’s pitch in miniature: not “trust the robot”, but “put the robot inside the review machinery you already trust”.
The same week, GitHub also added a public-preview Agent tasks REST API for Copilot Business and Enterprise users. This lets teams start Copilot cloud agent tasks programmatically. GitHub’s examples are revealing: fan out refactors or migrations across many repositories, create new repositories from an internal developer portal, or automatically prepare a weekly release including release notes. The cloud agent runs in its own development environment, makes and validates changes, then opens a pull request. Progress can be tracked through the API.
For agencies, that API is the more important product signal. The durable use case for agentic coding may not be one developer asking for one feature. It may be scripted delegation: “apply this security header change across 40 client apps”, “prepare Laravel upgrade PRs where the test suite passes”, “generate a first-pass accessibility fix for every failing template”, or “open a draft PR for each Dependabot bump that needs manual intervention”. None of those jobs should go straight to production. All of them fit naturally into GitHub’s PR-shaped control system.
GitHub is also pushing the agent experience back into familiar IDEs. Its JetBrains update brings the Copilot CLI agent into JetBrains IDEs in public preview, with editor context already connected. Developers can choose worktree isolation, where changes happen in a separate Git worktree until reviewed and applied, or workspace isolation for faster direct iteration. A unified sessions view shows running and queued sessions, with title, agent type, elapsed time and status. There is also support for global `.agent.md` configuration under `~/.copilot/agents`, suggesting teams will increasingly define reusable agent roles and behaviours rather than writing one-off prompts.
That last detail is easy to miss. An agency that wants consistent agent behaviour across projects — coding standards, testing expectations, review preferences, “don’t touch billing logic without asking” — needs configuration, not vibes. Global and workspace-level agent files are one route towards making AI assistance operationally boring enough to trust.
The model layer is changing too. On 17 May, GitHub made GPT-5.3-Codex the base model for Copilot Business and Enterprise organisations, replacing GPT-4.1 where no other model has been approved through internal review. GitHub says GPT-5.3-Codex is its first long-term support model in partnership with OpenAI, guaranteed to be available for 12 months from its February 2026 launch date. It carries a 1x premium request multiplier; GPT-4.1 remains force-enabled at a 0x multiplier for now but is due to deprecate alongside usage-based billing on 1 June.
The LTS point is important for anyone running AI through client or regulated workflows. Better benchmark scores are useful; predictable availability is often more useful. If a firm has to review model behaviour, update internal policies, reassure clients and retune prompts, it cannot have the default coding model changing every few weeks without a plan. GitHub is acknowledging that model governance is now part of developer tooling.
There are still reasons to be cautious. The Copilot app is a technical preview. Business and Enterprise access depends on admins enabling previews and the Copilot CLI policy. The REST API does not yet support GitHub App installation access tokens, though GitHub says that is coming, and Pro/Pro+ support is also still on the way. The claim that GPT-5.3-Codex has a high code survival rate among enterprise customers is interesting, but GitHub did not publish enough detail in the changelog to treat it as an independent quality benchmark.
There is also a cost-management story under the surface. Auto model selection now works in Copilot cloud agent, with GitHub saying it chooses the best available model based on system health and model performance, gives a 10% discount on the normal model multiplier, and avoids weekly rate limits. That may be helpful, but it also nudges teams into thinking of agent runs as metered production workloads. If agents are fanning out migrations across repositories, someone has to own the budget, the audit trail and the definition of “done”.
The practical takeaway is that agentic coding is becoming less like a better chat box and more like a queue of delegated software tasks. GitHub’s advantage is that it already owns much of the queue: issues, PRs, checks, code review, Actions, permissions and repository policy. Its new Copilot surface area is designed to keep AI-generated work inside those rails.
For a small technical team, that suggests a sensible adoption path. Do not start by asking an agent to “build the feature”. Start with contained, review-heavy work: dependency upgrades, test scaffolds, repetitive refactors, documentation updates, release notes, failing-check fixes, or cross-repo housekeeping. Require isolated branches or worktrees. Make the PR the handover point. Track which tasks survive review with fewer edits, not which demo looks most magical.
The important shift is not that Copilot can write more code. It is that GitHub is building the control plane around delegated software work. If that layer proves reliable, the competitive question for developer tools will move from “which model is smartest?” to “which platform lets a team safely assign, observe, review and ship agent work at scale?”