9.1 Copilot Suggestions, Agents, Agent Mode, and Multi-Model Support

Why GH-900 tests Copilot's assistive and agentic surfaces

Domain 4 of GitHub Foundations (GH-900) is 10–15% of the exam. After GitHub Actions, the January 2026 outline asks you to identify how GitHub Copilot assists with AI-powered code suggestions, including Copilot agents, Agent Mode, and multi-model support. GH-900 is not grading whether you can name this month's model catalog. It is asking whether you can tell a developer which Copilot surface does the job, where the work actually runs (the editor versus GitHub), and who still has to review the result.

GitHub Copilot is GitHub's AI coding assistant and agent platform. GitHub Docs group the product into assistive features—tools that advise you while you stay in the loop—and agentic features—tools that can work with more autonomy. Agentic tools still typically need human approval for sensitive actions such as running commands in a developer's terminal or merging a pull request. If a scenario ends with “merge it without a person looking,” that is not how Copilot is documented.

Assistive features: inline suggestions, chat, and summaries

Inline suggestions (completions) are autocomplete-style proposals in supported IDEs. You type, ghost text appears, and you accept, reject, or keep typing. In Visual Studio Code, Xcode, and Eclipse, Copilot can also offer next edit suggestions, which predict the location of the next edit you are likely to make and suggest that change. Next edit suggestions are still assistive: they propose the next local edit, they do not take over the workspace. Copilot Free limits inline completions to 2,000 per month. On paid plans, completions with included models are treated as unlimited and are not billed as GitHub AI credits.

Copilot Chat is a conversational interface for coding-related questions. GitHub documents Chat on the GitHub website, in GitHub Mobile, in supported IDEs, and in Windows Terminal. Chat is the right product when the stem is “explain this function,” “draft a unit test,” or “what does this error mean?” rather than “fill in the next line as I type.” Chat also supports inline chat in the editor and slash commands. Copilot Chat skills in IDEs are documented as not available on Copilot Free.

Two related assistive tools show up in “what can Copilot do on GitHub / Desktop?” stems:

• Copilot pull request summaries generate an AI description of what a pull request changed, which files it touched, and what a reviewer should focus on.
• Copilot in GitHub Desktop can draft commit messages and descriptions from the local diff.

Those tools still leave the human in charge of the commit, the summary text, and the review. They are not Agent Mode and they are not the cloud agent.

Agent Mode is local, multi-step, and still yours to approve

Agent Mode (agent mode in IDEs) is the Copilot Chat mode that lets Copilot work autonomously inside the IDE. GitHub's features documentation is the sentence to memorize: Copilot determines which files to make changes to, offers code changes and terminal commands for the user's approval, and iterates to remediate issues until the original task is complete. The working copy is your local (or Codespaces) workspace. You stay at the keyboard. That is the contrast with a single inline completion (one suggestion at the cursor) and with a Chat answer that only talks.

If a GH-900 stem says a developer wants Copilot to edit several files, run tests or other terminal commands, and keep going until the bug is fixed while they watch the diff in the editor, pick Agent Mode. Do not pick inline completions (too small), Copilot code review (comments on an existing PR), or Copilot cloud agent (that work happens on GitHub in the background, not as a live local loop).

GitHub currently documents that content exclusion (file exclusions from Copilot) does not apply to Agent Mode in IDE Chat or to Copilot CLI. An organization can hide files from ordinary completions and Chat and still need a separate policy conversation for agentic local tools. That limitation is a policy detail Domain 6 will expand; here it helps you keep Agent Mode in the “local, powerful, still needs a human” bucket.

Copilot agents: CLI, app, cloud agent, and partners

Copilot agents is the family of more autonomous workers, not a single button:

Copilot CLI puts Copilot in the terminal so you can add a feature or fix a bug, then open a pull request. GitHub documents that sessions can start in the terminal and continue on GitHub.com or GitHub Mobile. Tools that modify or execute files generally require approval unless you have explicitly allowed them.

The GitHub Copilot app is a desktop application for agent-driven development: run multiple agent sessions in parallel across repositories, manage issues and pull requests, and set up automations on a schedule.

Third-party coding agents (public preview) can run alongside Copilot cloud agent. GitHub currently names partners such as Anthropic Claude and OpenAI Codex in organization policy screens. They are subject to the same security protections as Copilot cloud agent. They are a paid-plan capability; Copilot Student includes agents but excludes third-party agents. Organization owners can disable partner agents even when the cloud agent itself is on.

GitHub's plans overview states that all current Copilot plans include Copilot CLI and the Copilot app. Agent depth still depends on plan: Copilot Free is documented as limited agents; Student includes agents except third-party; paid plans include the full agent set subject to admin policy.

Copilot cloud agent, code review, and multi-model support

Copilot cloud agent works on GitHub, not in your IDE

Copilot cloud agent is the autonomous agent that researches a repository, creates an implementation plan, and makes code changes on a branch. You review the diff, iterate, and create a pull request when you are ready. You can also tell it to open the pull request immediately. Other entry points GitHub documents: assign a GitHub issue to Copilot, start from Copilot Chat, the agents panel on GitHub.com, Visual Studio Code, GitHub Mobile, the REST API, or the GitHub CLI. On an existing pull request, mention @copilot in a comment to ask it to change the branch.

The agent runs in an ephemeral development environment powered by GitHub Actions. It can explore the code, run automated tests and linters, and push commits. GitHub is explicit that this is not Agent Mode. Copilot cloud agent works autonomously on GitHub in the background. Agent Mode makes autonomous edits in your local development environment. That contrast is the highest-yield D4.2 discriminator.

GitHub's own comparison with traditional IDE assistants is the exam story: IDE pairing is synchronous and local; cloud agent work is asynchronous, logged as commits, and visible to the team. You can research and plan before any pull request exists, which is why GitHub describes the flow as research → plan → branch → human review. Deep research and iterate-before-PR are documented for Copilot cloud agent on GitHub.com (and, in public preview, some chat integrations). Other issue-tracker integrations may only support creating a pull request directly.

Limits worth remembering at Foundations level:

• Available on paid Copilot plans. For Copilot Business and Copilot Enterprise, an administrator must enable the policy; GitHub documents the cloud agent as disabled by default for organization members who receive those seats. Repository owners can opt out some or all repositories.
• One repository per run, one branch at a time, and exactly one pull request per assigned task. It cannot change multiple repositories in one session.
• Maximum execution time is 59 minutes (a hard cap). Break large jobs into smaller tasks.
• Works only with repositories hosted on GitHub.
• Incompatible rulesets or branch protection (for example, only specific commit authors) can block the agent; rulesets can add Copilot as a bypass actor when that is the intent.
• Your approval of a Copilot-created pull request does not count toward required review counts. Another reviewer must approve before merge.
• Usage consumes GitHub Actions minutes and GitHub AI credits (credits depend on the model and tokens).

Quality improves when the repository teaches the agent how the project works: custom instructions (including .github/copilot-instructions.md), Model Context Protocol (MCP) servers, custom agents (specialized variants with their own tools and instructions), agent skills, and Copilot Memory (public preview on personal paid plans). Those customization names can appear as distractors; they do not change the core identity of the cloud agent.

Copilot code review is feedback on a diff, not a required human approval

Copilot code review produces AI-generated review comments and suggested changes so you can write better code. GitHub's responsible-use language: it reviews pull request diffs and metadata on GitHub.com. You can request a review or configure automatic review on target branches. Some preview tools can pass suggestions to Copilot cloud agent so fixes land in a follow-up pull request or commit—still a reviewer handing work to an implementer, not the same feature.

Two merge-related facts GH-900 can twist:

• Copilot's reviews do not count toward required approvals.
• Copilot's reviews do not block merging by themselves (unless a separate ruleset is written to gate on findings).

If the stem wants comments on an existing pull request, pick Copilot code review. If it wants Copilot to implement the change on a new branch and open a PR, pick Copilot cloud agent. If it wants Copilot to drive a multi-file fix in the IDE right now, pick Agent Mode.

Multi-model support: teach the capability, not a SKU list

Multi-model support means Copilot can run on more than one AI model, including models from multiple providers, and that users and organizations can choose which models are available. GitHub's catalog changes frequently. GH-900 tests the capability and the plan gate, not a memorized product name. If you are unsure of a model name, do not invent one on the exam or in real life—describe auto-select versus paid choice.

Documented plan rules:

• Copilot Free and Copilot Student: model access is auto model selection only. There is no picker.
• Paid individual plans: Copilot Pro includes a selection of models; Copilot Pro+ adds access to premium models; Copilot Max adds priority access to premium models. On supported cloud-agent entry points you can also select the model (and, for some models, a reasoning level) when you start a task.
• Copilot Business: access to premium models, with organization Models policy able to restrict the catalog (some models consume extra AI credits).
• Copilot Enterprise: priority access to premium models, with enterprise policy for which organizations receive which models.

Pick a more capable model when the task is a hard, multi-file refactor; leave auto-select or a cheaper included model for a one-line rename. AI credits are the meter for chat, agents, and premium-model usage; included-model inline completions on paid plans are not billed as credits. Organizations that care about cost use the Models policy rather than leaving every premium model on for every seat.

Exam traps for D4.2

• Inline ≠ Chat ≠ Agent Mode ≠ cloud agent ≠ code review. Ghost text at the cursor; a conversation; a local multi-file loop with approved commands; GitHub-hosted research/plan/branch/PR; comments on an existing PR.
• Agent Mode is not the cloud agent. Local workspace versus an Actions-powered environment on GitHub.
• Humans still review. Copilot does not satisfy required reviewers. Copilot does not merge by default.
• Free and Student cannot pick models. Auto selection only.
• Do not memorize a model SKU list. Catalogs change; the exam tests selection and plan gates.
• Cloud agent is a paid-plan feature, and Business/Enterprise policy may keep it off until an admin enables it.
• Next edit suggestions are still assistive completions, not Agent Mode.
• PR summaries describe a pull request; they do not implement the change.