GitHub announced on July 27, 2026 that the GitHub Copilot app has its own access policy at the enterprise and organization levels. Previously, access to the Copilot app depended on the GitHub Copilot CLI policy. Separating those controls gives administrators a more precise decision to make, but it also creates a migration risk: a team can believe the app is governed while the effective policy, managed settings, license assignment, or repository access still produces a different result.
GitHub documents the new policy and its administration model. This article provides CodeRiskTools review guidance; it does not claim that we tested GitHub’s hosted controls in a customer organization. An enabled policy is not proof that generated code is safe, that data exposure is acceptable, or that every client applies the same settings. Verify the effective state and keep a human owner for consequential changes.
What the dedicated app policy changes
The changelog says administrators can control Copilot app access independently from Copilot CLI access. That distinction matters because the clients have different workflows and may be used by different groups. A developer who needs CLI access for a documented local workflow may not need the app, while an organization may want the app enabled only for a pilot group. Treat the policy split as an access-boundary change, not as a cosmetic settings rename.
Start by writing down the intended state before changing anything. Record which enterprise and organization should inherit the setting, which teams receive Copilot licenses, which client surfaces are in scope, and which repositories may be used for agent work. If the expected state is not explicit, a successful sign-in is weak evidence.
Build an access inventory
| Surface | Question | Evidence to retain |
|---|---|---|
| Enterprise policy | Is the Copilot app allowed, denied, or inherited at the enterprise level? | Policy view, effective date, owner, and change record |
| Organization policy | Does the organization override or narrow the enterprise setting? | Organization setting, target groups, and exception rationale |
| Client access | Can the intended user open the app while an unintended user is denied? | Positive and negative test identities, timestamps, and result |
| Managed settings | Are centrally managed Copilot settings applied to the app as expected? | Repository revision, JSON configuration, propagation time, and readback |
| Repository scope | Which repositories, instructions, tools, and data can the user or agent reach? | Repository allowlist, permissions, and review owner |
Use a seven-step policy migration workflow
- Capture the baseline. Export or record the current Copilot CLI policy, app availability, license assignments, organization overrides, managed settings, and relevant repository restrictions. Keep the evidence private and access-controlled.
- Define the target groups. Name the pilot, production, and excluded groups. Do not use a broad enterprise enablement as a substitute for an access decision.
- Change one policy boundary. Enable or disable the dedicated app policy without simultaneously changing unrelated model, agent, repository, or spending controls. A narrow change is easier to attribute and roll back.
- Test both sides. Use a permitted test identity and a denied test identity. Check the app and CLI separately, because the new control is intended to distinguish them.
- Verify managed settings. If settings are delivered from a private configuration repository, pin the reviewed revision and confirm the app receives the intended values after the documented propagation interval. A source-file change alone is not an effective-state readback.
- Review repository and data access. Confirm the test account can reach only the repositories and resources expected for its role. Include custom instructions, agent tools, MCP connections, issue text, and private source in the threat model.
- Record approval and rollback. Link the policy change to an owner, ticket, exact before/after state, test evidence, and a reversal procedure. If the negative test fails, restore the last known state and investigate before expanding access.
Separate access control from safe use
An app policy answers who may use a client; it does not answer what the client may read, what tools an agent may call, or whether generated changes are suitable for merge. Keep those controls separate. Use least-privilege repository permissions, protect sensitive branches, review instruction files, and keep production credentials outside ordinary coding-agent context. If an agent can create a pull request, open an issue, or call an external tool, record those side effects and require the appropriate human approval.
- Grant access to a named group instead of everyone by default.
- Keep CLI and app decisions documented independently.
- Use a disposable or low-risk repository for first-use testing.
- Test denial, revocation, and removal from a group, not only initial enablement.
- Do not treat a generated explanation or successful sign-in as security proof.
- Redact tokens, private source, customer data, and internal policy values from shared evidence.
Managed settings need an effective-state check
GitHub’s July 27 managed-settings announcement says enterprise-managed settings can apply to the Copilot app through a private repository and a managed-settings JSON file. This is useful for consistency, but it creates a familiar configuration problem: the committed file, the service’s received configuration, and the user’s visible behavior can diverge during propagation or after an invalid value. Pin the configuration revision, validate the JSON before commit, record the expected keys, and verify the client after the documented update window or restart behavior.
Do not infer that every setting is supported by every client. Compare the current policy documentation with the app’s documented capabilities, and mark an unsupported, delayed, or unmeasured result explicitly rather than calling it compliant.
Failure modes to catch before rollout
| Symptom | Review question | Safer response |
|---|---|---|
| App access follows the old CLI decision | Was the dedicated app policy actually changed at the effective enterprise or organization scope? | Read back both policies and test the same identities in both clients. |
| Denied user can still use the app | Is another organization, license, or inherited setting granting access? | Trace inheritance and group membership before widening or repeating changes. |
| Managed settings appear stale | Was the expected revision applied, and has the documented propagation interval elapsed? | Record the revision and retest after a controlled restart; do not assume source parity. |
| Access is correct but repository scope is broad | Can the user or agent reach private repositories, tools, or instructions outside the role? | Narrow repository permissions and agent/tool scope separately from the app policy. |
| Rollout evidence contains sensitive data | Did logs or screenshots include tokens, source, or customer records? | Redact at collection and retain only the minimum evidence needed for audit. |
FAQ
Does the dedicated policy make Copilot app use secure?
No. It improves administrative separation between app and CLI access. Repository permissions, data handling, agent tools, instructions, branch protection, and human review remain separate controls.
Should an enterprise enable the app for every licensed user?
Not automatically. Define the intended groups and test a limited rollout first. Licensing, policy access, and repository authorization are related but different states.
How should administrators test a denial?
Use a non-production test identity that is not in the permitted group, then verify the app and CLI independently. Record the policy scope and timestamp so an inherited setting or propagation delay is not mistaken for a control failure.
Are managed settings the same as policy?
No. Policies control access to features, agents, or models. Managed settings can configure client behavior, but the effective keys, supported clients, and update timing must be checked against current GitHub documentation.
Official sources and next step
- GitHub Changelog: Manage Copilot app access with a dedicated policy — the policy separation announcement.
- GitHub Docs: Copilot policies for enterprises and organizations — policy inheritance and administration context.
- GitHub Docs: About the GitHub Copilot app — documented app availability and requirements.
- GitHub Changelog: Enterprise managed settings apply to the Copilot app — managed-settings behavior and configuration path.
- GitHub Docs: Managing policies and features — organization administration guidance.
For a compact starting point, use the free 5-point AI code review checklist. For a local, intent-bound review before merge, see the documented scope of the AI Change Firewall. Use the single CodeRiskTools comparison hub for scope context; none of these resources replaces GitHub controls or human authorization.
Approve the effective boundary
Before broad rollout, bind the policy to named groups, effective settings, repository scope, positive and negative tests, and a rollback owner. If any state is inferred rather than read back, keep the rollout limited.
