What Is the GitHub Copilot App?
At its Universe conference in San Francisco on October 28, 2026, GitHub announced a product it has been building toward for two years: the GitHub Copilot app, a standalone, agent-first workspace that carries software work from an issue all the way to a merged change in one place. If you have used Copilot only as an autocomplete inside your editor, this is a different kind of tool. The GitHub Copilot app is not a plugin. It is a home base for directing agents: you describe the outcome you want, the GitHub Copilot app runs agents across your projects, and you review, steer, and approve what they produce.
That distinction matters because the job of a developer is changing fast. GitHub’s own usage data, released alongside the announcement in its Octoverse report, shows that more than 40% of pull requests on the platform started with an agent’s first draft in September 2026, up from 17% in March. In the same month, 61% of Copilot users who picked a model themselves used more than one. The GitHub Copilot app is GitHub’s answer to that shift: instead of you chasing agents across an editor, a terminal, a chat window, and the web, the agents come to one surface where you can watch them all.
Think of it this way. The old Copilot helped you write code faster. The new GitHub Copilot app helps you run a small team of agents that write, test, review, and document code while you stay in charge of decisions. You still set direction, and you still approve what ships. The agents do the legwork: opening branches, running tests, opening pull requests, and reporting back when they need a human call.
This guide explains everything the GitHub Copilot app does, what is new in the October 2026 release, how the new Enterprise pricing works, and what it actually costs in US dollars. It also covers the honest limits: what is still in preview, what requires an account team rather than a self-service signup, and who should switch now versus who should wait. A short note on scope: GitHub also announced Copilot Fusion, its multi-model routing system, at the same event. Fusion decides which models run a task; this article is about the app itself and the pricing change, and it links to our separate Fusion explainer where the routing details belong.

Table of Contents
- What Is the GitHub Copilot App?
- Why GitHub Built a Separate App
- From Issue to Merge: How the GitHub Copilot App Works
- Copilot Projects: Multi-Repo Work in Parallel
- Computer Use: Agents That Operate Your Apps
- Slack, Figma, and Image Generation in Chat
- One Session Across App, Editor, CLI, and Web
- The Enterprise Pricing Change: No Separate Copilot Seat
- GitHub AI Credits Explained
- Every Copilot Plan Compared (2026 Prices)
- What Real Teams Will Actually Pay
- Who Should Switch, and Who Should Wait
- Security and Admin Controls Worth Knowing
- How to Get Started With the GitHub Copilot App
- Honest Limits and Open Questions
- The Verdict: Is the GitHub Copilot App Worth It?
- Frequently Asked Questions
Why GitHub Built a Separate App
To understand the GitHub Copilot app, it helps to see the problem GitHub says it is solving. Two years ago, a developer wrote nearly every line of code by hand, and an AI assistant suggested the next few lines. Today, that same developer may supervise several agents at once: one fixing a bug, another writing tests, a third reviewing a pull request. Each agent lives somewhere different, and keeping track of them becomes a job of its own.
GitHub’s framing at Universe 2026 was blunt: the company wants to be, in its words, “the most comprehensive software delivery system in the world.” That is a bigger ambition than a code editor plugin. The GitHub Copilot app is the surface where that ambition becomes something you can open on your computer. It connects agents and tools across projects so you can direct the work without making every handoff yourself.
There is also a practical reason for a separate app. Much of software work is not code at all. Writing a specification, presenting a design discussion, or analyzing telemetry from production are all part of shipping software, and none of them fit neatly inside a code editor. GitHub explicitly positions the GitHub Copilot app as a place for those jobs too: you can write specs, discuss designs, and dig into telemetry in the same agent-first surface where your code work happens.
Finally, the app reflects how teams actually work now. A feature rarely lives in one repository. It touches an API service, a web frontend, a mobile client, and a documentation site. The old model, one agent in one repo, breaks down at that scale. The GitHub Copilot app is built around multi-repo work from the start, which is why its headline feature is called Copilot Projects, covered in detail below.
From Issue to Merge: How the GitHub Copilot App Works
The core workflow of the GitHub Copilot app follows the lifecycle GitHub describes as “issue to merge.” You start with a goal, usually a GitHub issue, and the app carries it through implementation, testing, review, and a pull request ready for a human to merge. Here is how that plays out in practice.
Step 1: Describe the Goal in the GitHub Copilot App
You open the GitHub Copilot app and describe what you want in plain language: fix a bug, add a feature, refactor a module, or write a specification. You attach context by pointing at repositories, issues, design files, or chat threads. The more specific the goal, the better the agents perform, just as with any AI tool. Vague goals produce vague pull requests, so experienced users treat the goal description as the most important step.
Step 2: Agents Run in Managed Sessions
The GitHub Copilot app then runs agent sessions, often several in parallel, in fully managed cloud environments. Each session works on its own branch, runs tests, and reports progress in one place. You do not babysit the terminal. You watch progress, answer questions when an agent gets stuck, and redirect it when it heads the wrong way. This is the “directing” part of the job: you are the manager, and the agents are the team.
Step 3: Review, Decide, and Merge
When a session finishes, it produces something reviewable: a pull request, a specification draft, or a design discussion summary. You review it like any other contribution, request changes if needed, and merge when it meets your bar. Branch protections and existing repository policies still apply, so an agent cannot merge its own work past rules you set. That human checkpoint is the feature that matters most, and it is worth checking that your branch protections are actually on before you hand agents real repositories.

Copilot Projects: Multi-Repo Work in Parallel
Copilot Projects, available natively in the GitHub Copilot app starting October 28, 2026, is the feature that separates the app from a chat window with a code tool attached. A project is a workspace for work that spans more than one repository, or is not code at all. You describe a goal, add context such as repositories, design files, and chat threads, choose which models and tools the agents may use, and the app runs several agents in parallel, returning results such as pull requests ready for review.
Why does this matter? Consider a realistic example. Your team wants to add single sign-on to a product. That touches the API service, the web app, the mobile app, and the docs. In the old world, you would run four separate agent sessions and stitch the results together yourself. In a GitHub Copilot app Project, one workspace tracks all four streams, so you see progress, decisions, and blockers in a single view. When one stream changes an API contract, the others can react, because they share the project’s context.
Projects are in public preview, which means they are usable but still evolving. Expect rough edges: some workflows will feel unfinished, and availability may vary by workspace as GitHub rolls the feature out gradually. For teams already juggling multi-repo work, though, the preview is worth trying on a low-risk project before committing real deadlines to it.
It is also worth noting what Projects are not. They are not a project-management tool to replace your issue tracker. They are an execution workspace: the place where agent work happens and gets tracked, while your issues and roadmaps stay where they are. Think of a project as a mission-control room for one goal, not a new backlog.
Computer Use: Agents That Operate Your Apps
The most talked-about addition to the GitHub Copilot app is computer use, released in public preview for macOS and Windows on October 28, 2026. With computer use, Copilot can read what is displayed in an application, click interface elements, enter or edit text, and move across applications, including ones with no API, command-line interface, or integration at all. In plain terms, the agent can use your computer the way you do.
The obvious use case is legacy software. Every company has tools that were never built for automation: an old internal dashboard, a vendor portal, a desktop app with no API. Until now, agents simply could not touch those. Computer use opens that door, which is why GitHub pairs it with explicit guardrails: the agent asks for approval before taking control of an app, and organizations can disable the feature entirely through managed settings.
Turning it on is deliberately manual. It is enabled per machine in the app’s settings, under Settings, then Computer Use, then Enable Computer Use. On macOS, you must also grant Accessibility and Screen Recording permissions, which is the operating system making sure you really mean it. That friction is a feature, not a bug: an agent with screen control is powerful, and it should never be switched on by accident.
Security teams should think carefully before rolling computer use out widely. An agent driving applications by clicking around does not always leave the clean audit trail an API call would. Before enabling it across an organization, keep it off by default through managed settings, limit it to pilot accounts on dedicated machines, and watch what those pilots actually do. The capability is genuinely useful for narrow, well-defined jobs, but it deserves a pilot phase, not a company-wide switch-on.
Slack, Figma, and Image Generation in Chat
Alongside Projects and computer use, the GitHub Copilot app gained connectors to Slack and Figma, plus image generation inside chat. These sound like small additions, but they fix a real frustration: agents that can only see code miss the context where decisions actually get made.
With the Slack connector, the GitHub Copilot app can draw on conversation history to research a request or draft a specification. If your team debated an API design in Slack last week, the agent can find that thread and use it, instead of asking you to paste it in. With the Figma connector, it can pull design context alongside code, so a request like “build this screen” starts from the actual design file rather than a screenshot description.
Image generation and editing from natural-language prompts now lands directly in chat as well. That brings the GitHub Copilot app closer to consumer image tools for quick illustration or mockup needs: you can ask for a diagram, a placeholder illustration, or a mockup variation without leaving the conversation. It will not replace a dedicated design tool, but for the quick visuals that pepper specifications and documentation, it removes a round trip.

One Session Across App, Editor, CLI, and Web
Another quiet but important change: a cloud agent session can now follow a developer between the GitHub Copilot app, VS Code, the command line, and the web. Start a task in the GitHub Copilot app during planning, continue it in your editor while you review code, check it from the terminal, and pick it up on the web later, without restarting or losing context.
This matters because developers do not live in one surface. A morning might start in a meeting, move to an editor, and end in a terminal. Before this change, each surface meant a fresh session and a fresh explanation of the task. Now the session is the unit of work, not the window. If you have ever re-explained a task to a chatbot three times in one day, you know why this is a quality-of-life win worth more than it sounds.
For teams, the handoff also makes agent work more visible. A colleague can open the same session on the web and see where a task stands, instead of asking for a status update. That visibility is the difference between agents as a personal productivity trick and agents as a team workflow.
The Enterprise Pricing Change: No Separate Copilot Seat
The second half of the Universe announcement is a pricing change, and for large organizations it may matter more than any feature. Starting October 28, 2026, GitHub Enterprise customers can use all Copilot features without buying a separate Copilot subscription. That includes the GitHub Copilot app, code review, and automations. Instead of paying per Copilot seat, you pay for the AI credits you use.
This is a real structural change. Until now, giving Copilot to an organization meant buying a Copilot seat for each developer on top of their GitHub Enterprise license. Under the new arrangement, every licensed Enterprise user can get Copilot features, and the bill follows actual AI usage instead of headcount. For a company with thousands of engineers, many of whom use Copilot lightly, that can be a very different bill, and usually a smaller one.
There are three important conditions to understand before you get excited. First, the offer is currently available through GitHub Sales, meaning customers who work with a GitHub or Microsoft account team. Self-service sign-up is coming, but GitHub has not set a date, saying only that it will share dates in the coming weeks. If you buy GitHub self-service today, you cannot flip this switch yourself yet. Second, existing Copilot Business and Copilot Enterprise subscriptions stay on sale, and existing customers can keep their current plans or move over when ready. Nobody is being forced to migrate. Third, people in an enterprise account who do not hold a GitHub Enterprise license can get the same Copilot features through Copilot Standalone at $10 per user per month, which is the route for contractors and occasional collaborators.
Why would GitHub do this? The honest answer is that usage-based billing fits how agents actually work. A seat-based price assumes every developer uses roughly the same amount of AI. Agent workflows break that assumption completely: one developer running a fleet of agents overnight can consume many times more model output than a colleague who only uses autocomplete. Tying the bill to consumption aligns what you pay with what you actually run, and it removes the awkward question of whether to buy seats for people who barely use the tool.
GitHub AI Credits Explained
To understand the new pricing, you need to understand GitHub AI Credits, the usage currency GitHub introduced on June 1, 2026. The system replaced the old “premium request” counting, and it works like this: one AI credit is worth $0.01, and each interaction spends credits based on the tokens it consumes, input, output, and cached tokens, priced at each model’s published API rate. A cheap, fast model burns few credits; a heavy frontier model burns many.
Every Copilot plan includes a monthly credit allowance equal to its seat price, pooled across the organization for team plans. Copilot Business at $19 per user per month includes 1,900 credits per user, and Copilot Enterprise at $39 includes 3,900 credits per user. For individuals, Copilot Pro at $10 per month includes 1,500 credits, Pro+ at $39 includes 7,000, and Max at $100 includes 20,000, with the individual plans also carrying a flex allotment on top of their base credits. Anything beyond the pool is billed at $0.01 per credit.
Crucially, not everything consumes credits. Code completions and next-edit suggestions are unlimited and consume no credits at all, so a developer who only uses autocomplete sees no change in cost under any plan. What does consume credits: Copilot Chat in every interface, agent sessions, Copilot in the command line, and code review. Note also that Copilot code review consumes GitHub Actions minutes in addition to AI credits, which is a second meter worth watching on your bill.
Under the new credits-only Enterprise arrangement, the mechanics change in one key way: usage is metered from the first request against the enterprise’s AI budget, with no monthly credit allowance attached to each seat. There is no included pool to burn through first; you simply pay for what you run. That is simpler to reason about, but it also means there is no free buffer, so budget controls and usage reporting become the first things to set up, not an afterthought.
One safety net survives running out of budget: code completion and next-edit suggestions keep working even with no budget left. What stops is the expensive stuff: Copilot Chat, Copilot code review, and Copilot in the cloud need money in the budget to run. That design means a team never loses basic autocomplete because of a billing surprise, but agent work halts until the budget is topped up, so plan your budget alerts accordingly.

Every Copilot Plan Compared (2026 Prices)
Here is the full lineup as it stands in late October 2026, with the new credits-only Enterprise option added at the end. Prices are in US dollars, per month, and exclude the underlying GitHub Enterprise Cloud license where noted.
| Plan | Price | Monthly AI credits | Best for |
|---|---|---|---|
| Copilot Free | $0 | Limited allowance | Trying Copilot, students, hobby projects |
| Copilot Pro | $10 | 1,500 ($15 value) | Individual developers |
| Copilot Pro+ | $39 | 7,000 ($70 value) | Heavy individual and agent power users |
| Copilot Max | $100 | 20,000 ($200 value) | Sustained, all-day agent users |
| Copilot Business | $19 per user | 1,900 per user, pooled | Teams needing controls and IP indemnity |
| Copilot Enterprise | $39 per user | 3,900 per user, pooled | Large orgs wanting custom models and deep integration |
| Enterprise credits-only (new) | Pay per credit used | No seat allowance; metered from first request | Enterprise Cloud customers via GitHub Sales |
| Copilot Standalone | $10 per user | Per plan terms | Non-Enterprise-licensed users in an enterprise account |
Two details in that table deserve emphasis. First, Copilot Enterprise at $39 per user per month requires GitHub Enterprise Cloud, which is billed separately per user, so the real Enterprise cost has always been the Copilot seat plus the platform underneath it. The credits-only change removes the Copilot seat from that stack, but the Enterprise Cloud license itself remains. Second, Business and Enterprise credits are pooled across the whole organization, so light users offset heavy ones. A 100-person Business team gets one shared pool of 190,000 credits, not 100 separate allowances, which smooths out the month-to-month variance of individual usage.
What Real Teams Will Actually Pay
Pricing tables are abstract, so here are three realistic scenarios that show how the new model changes the bill. These are illustrative estimates based on the published $0.01-per-credit rate, not quotes, because actual credit burn depends heavily on which models your agents use.
A 20-Person Startup
A 20-person startup on Copilot Business pays $380 per month and gets a pooled 38,000 credits. If the team uses Copilot mainly for completions and occasional chat, it may never touch the pool, and the bill stays flat. If two engineers start running heavy agent sessions daily, the pool drains faster, and overage bills at $0.01 per credit. For this team, the existing Business plan is probably still the right call: the included pool acts as a predictable buffer, and the per-seat price is low.
A 2,000-Engineer Enterprise
Now consider a 2,000-engineer company on Copilot Enterprise. Under the old model, that is $78,000 per month in Copilot seats alone, before the Enterprise Cloud license, regardless of how much anyone actually uses. In practice, usage is wildly uneven: a few hundred engineers drive agents hard, while many others barely open chat. Under the credits-only model, the company pays only for credits consumed. If actual consumption works out to, say, $40,000 of credits in a month, the saving is substantial. If the whole company goes agent-heavy, the bill could exceed the old seat total, which is why GitHub itself advises asking your account team for usage reporting first. The honest truth is that credits-only rewards accurate measurement, and punishes flying blind.
A Company With Many Occasional Users
The biggest winners are organizations with a long tail of occasional users: support engineers, data analysts, or product managers who need Copilot a few days a month. Under seat pricing, each of those people cost $39 a month whether they used the tool or not. Under credits-only, they cost almost nothing in quiet months. That is the population GitHub is clearly targeting, and it is also why the change pairs naturally with the GitHub Copilot app: the app makes it easy for non-developers to direct agents for specs and analysis, and credits-only makes it cheap to let them try.
Who Should Switch, and Who Should Wait
Switch to credits-only Enterprise now if you are already a GitHub Enterprise Cloud customer working with an account team, your Copilot usage is uneven across the organization, and you have, or can get, usage reporting before you commit. The combination of uneven usage plus real reporting is where the model wins. Ask your account team for a usage report covering the last three months, and compare actual credit consumption against what your current seats cost.
Stay on your current Copilot Business or Enterprise plan if you value predictable billing above all else, if your whole team uses Copilot heavily and evenly, or if you buy self-service. In those cases the included credit pool is a feature, not a limitation: it caps your monthly exposure and smooths spikes. There is no forced migration, so staying put costs nothing but the opportunity you are passing up.
Individual developers should mostly ignore this change. The credits-only option is an Enterprise arrangement, not an individual plan. If you code solo, Copilot Pro at $10 or Pro+ at $39 remains the sensible choice, and the GitHub Copilot app itself is available to you through your plan. The app is the product; the pricing change is about how big companies pay for it.
Security and Admin Controls Worth Knowing
Agent tools raise real governance questions, and GitHub has shipped controls alongside the capabilities. Organizations can disable computer use through managed settings, set credit budgets and limits to prevent surprise overage, and rely on existing branch protections so agent work still passes human review before merging. Copilot code review now comes in tiers, including a Max tier that GitHub says posted the highest F1 score on ReviewBench for high-severity issues, with Lite and Balanced tiers remaining for faster routine reviews.
Three practical controls to set on day one: first, turn on budget alerts well before the budget runs out, because agent work halting mid-sprint is worse than a slightly larger bill. Second, require human review on every agent-created pull request, even for low-risk repositories, until the team has seen a month of agent output quality. Third, keep computer use restricted to pilot machines until you understand what it touches in your environment. These are not exotic precautions; they are the basics that separate a successful agent rollout from a messy one.

How to Get Started With the GitHub Copilot App
Getting started is straightforward, with one caveat: the newest capabilities roll out gradually, so some features may not appear in your workspace on day one. Here is the path that works for most people.
- Update the app. On macOS, run
brew upgrade --cask github-copilot; on Windows, runwinget upgrade GitHub.CopilotApp. The October 28 capabilities, including Projects and computer use, require the latest build. - Sign in with your GitHub account and confirm your Copilot plan is active. The GitHub Copilot app works with individual plans and with Business and Enterprise entitlements.
- Start with one small project. Pick a low-risk, well-scoped goal, such as adding tests to a stable module, and run it as a Copilot Project. Watch how the agents report progress before trusting them with bigger work.
- Try a session handoff. Start a task in the GitHub Copilot app, continue it in VS Code, and check it on the web. If the handoff feels smooth, your workflow is ready for multi-surface agent work.
- Turn on computer use only if you need it. Go to Settings, then Computer Use, then Enable Computer Use, and on macOS grant the Accessibility and Screen Recording permissions. Keep it off by default for everyone else.
- Enterprise admins: talk to your account team. Ask for usage reporting and a credits-only quote before switching billing models. Compare three months of actual consumption against your current seat cost, and set budget alerts before migrating.
Honest Limits and Open Questions
No launch is complete, and the GitHub Copilot app has limits worth stating plainly. Copilot Projects and computer use are both in public preview, which means behavior can change and rough edges are expected. The credits-only Enterprise option is sales-only for now, with no self-service date announced, so smaller Enterprise customers may wait weeks before they can use it. GitHub has also not published committed-use discounts for credits-only contracts; those are negotiated account by account, which makes apples-to-apples comparison with seat pricing harder than it should be.
There are also questions the announcement does not answer. How much does a typical agent task cost in credits? That depends entirely on model choice and task size, and GitHub’s own advice is to measure your usage rather than guess. How good is the Max code review tier in practice? The ReviewBench claim is GitHub’s own benchmark result, not an independent evaluation, so treat it as a lead to test, not a verdict. And how far will computer use go in regulated environments? That will be decided by security teams, not by the feature list.
Finally, a note on competition. The GitHub Copilot app does not exist in a vacuum: Cursor, Claude Code, and other agent tools are all racing toward the same “direct a fleet” future. GitHub’s advantages are its 225 million developers on the platform, its ownership of the repository where the work lives, and now a pricing model that lets an entire enterprise try Copilot without buying a seat for everyone. Its disadvantage is that it must serve everyone from solo developers to the largest banks, which makes it slower to specialize than a focused rival. For teams already living on GitHub, though, the integration advantage is hard to beat.
The Verdict: Is the GitHub Copilot App Worth It?
The GitHub Copilot app is worth trying now if you already use Copilot and you manage, or want to manage, more than one agent at a time. Copilot Projects solves a genuine multi-repo headache, session handoff removes a daily annoyance, and computer use opens a class of work agents could not touch before. None of these features is magic on its own, but together they mark the point where Copilot stops being an assistant inside your editor and becomes a workspace for directing software delivery.
The pricing change deserves a separate verdict. Credits-only Enterprise billing is a genuinely better deal for organizations with uneven usage and good reporting, and a worse deal for nobody in particular, since existing plans stay available. Its only real risk is the one GitHub itself flags: without usage reporting, you cannot know whether you are saving money. Get the report first, then decide.
If you are an individual developer, the takeaway is simpler: update the app, try a Copilot Project on something small, and keep your current plan. If you run engineering for a large company, the takeaway is a homework assignment: call your account team, ask for three months of usage data, and run the credits-only math before your next renewal. Either way, the direction is clear. Software development is becoming the job of directing agents, and the GitHub Copilot app is GitHub’s bid to be the place where that job happens. For a fuller picture of how GitHub decides which models power those agents, read our companion guide to Copilot Fusion, and for moving sessions between different agent tools, see our Skillsync explainer. Agents are also reshaping how the rest of the economy buys and sells, as our Walmart Agent Gateway coverage shows.
Frequently Asked Questions
Is the GitHub Copilot app free?
The GitHub Copilot app itself is a workspace included with Copilot plans; there is no separate app subscription. Copilot Free costs $0 with a limited allowance, Pro costs $10 per month, Pro+ $39, and Max $100. Enterprise customers can now also access all Copilot features, including the app, by paying only for the AI credits they use, through GitHub Sales.
What is the difference between the GitHub Copilot app and Copilot in VS Code?
Copilot in VS Code is an assistant inside your editor, focused on the file you are editing. The GitHub Copilot app is a standalone, agent-first surface for directing work across projects, including multi-repo Copilot Projects, specs, design discussions, and telemetry analysis. A cloud session can now move between the app, VS Code, the command line, and the web.
How do GitHub AI Credits work?
One AI credit is worth $0.01. Chat, agent sessions, and code review consume credits based on token usage at each model’s published API rate. Code completions and next-edit suggestions consume no credits and keep working even if your budget runs out.
Can Enterprise customers really drop the Copilot seat?
Yes, as of October 28, 2026, GitHub Enterprise customers working with a GitHub or Microsoft account team can use all Copilot features, including the GitHub Copilot app, code review, and automations, paying only for AI credits consumed. Self-service sign-up is coming but has no announced date, and existing Copilot Business and Enterprise plans remain available.
Is computer use safe to enable?
Computer use is in public preview on macOS and Windows. The agent asks for approval before taking control of an app, and organizations can disable it through managed settings. For most teams, the safe path is a pilot on dedicated machines with the feature off by default everywhere else.
Do I need the GitHub Copilot app if I already use Copilot Fusion?
They do different jobs. Fusion is the routing system that decides which models run a task; the GitHub Copilot app is the workspace where you direct agents and track their work. Most users will use both: the app as the surface, Fusion as the engine underneath. Our Copilot Fusion explainer covers the routing side in depth.
Sources: GitHub’s Universe 2026 announcement and related coverage, including the official GitHub Blog post on the launch. Benchmark and pricing figures are GitHub’s own published numbers where noted; independent verification of benchmark claims was not available at publication time.
