Two Agents, Two Timelines

GitHub Copilot has expanded well beyond its 2021 autocomplete origins. As of 2025, it offers two distinct agentic capabilities that serve different purposes: agent mode, a synchronous collaborator working inside your editor, and coding agent, an asynchronous teammate operating in the cloud and delivering pull requests. Both are AI agents, but they are optimized for different phases of development work.

Agent Mode: In-Editor, Real-Time Collaboration

Agent mode turns Copilot Chat into an orchestrator of development tools—read_file, edit_file, run_in_terminal, and others. Give it a natural-language goal such as "add OAuth to our Flask app and write tests," and it will plan, edit files, run the test suite, interpret failures, and iterate until successful. You observe the steps, can interrupt when needed, and all changes remain local.

Enabling Agent Mode

  1. Open Copilot Chat in VS Code.
  2. Select Agent from the mode dropdown.
  3. Optionally, use Tools → Manage to enable or disable capabilities and add MCP extensions.

Getting More From Agent Mode

  • Be specific: "Generate a REST endpoint" is more useful than "help?" Vague instructions increase the chance of hallucinated output.
  • Supply context: Reference the spec file or paste the schema so the agent does not invent structures.
  • Intervene as it runs: Treat it like pair programming with a fast but direction-dependent partner.
  • Extend with MCP servers for custom tooling such as database migrations or cloud deployments.
  • Pick the right model: OpenAI GPT-4o for raw power, Anthropic Claude for longer context.

In short, agent mode functions as a skilled pair programmer working within your editor, writing code, running tests, and fixing errors immediately.

Coding Agent: Background Work on GitHub Issues

Coding agent operates where agent mode cannot: inside your repositories themselves. Assign an issue to Copilot, and it launches a secure cloud workspace via GitHub Actions, develops a plan, edits code on its own branch, runs your test suite and linters, then opens a pull request for your review.

Setting Up Coding Agent

  1. Check eligibility: Requires Copilot Pro+ or Copilot Enterprise.
  2. Enable via policy: Enterprise admins must turn on "Copilot coding agent" in organization policies.
  3. Assign an issue: Direct the coding agent to an issue using natural language.
### Feature: add dark‑mode toggle
assignees: Copilot

Best Fits and Limitations

Coding agent performs well on:

  • Low-to-medium complexity changes in well-tested repositories.
  • Adding or extending unit tests.
  • Small refactors like renaming a service or extracting helpers.
  • Documentation and typo fixes.

It is less suited to massive rewrites, cross-repo changes, or codebases with no test coverage.

Using Coding Agent Effectively

  • Write crisp acceptance criteria in the issue; they act as your spec.
  • Link files or functions the change will touch to cut exploration time.
  • Keep issues atomic: one logical task per issue scales better than monolithic requests.
  • Iterate via PR comments: request tweaks, then have the logic extracted into a separate function with proper error handling.
  • Watch your minute usage: heavy tasks consume Actions minutes and premium requests.

Choosing and Combining the Two

Agent mode and coding agent are complementary rather than interchangeable. Use them together across your development cycle rather than choosing one over the other.

  • Prototype in agent mode, ship with coding agent: Spike a working feature branch interactively, then open an issue describing remaining polish tasks and assign it to Copilot.
  • Draft specs with agent mode, implement with coding agent: Ask agent mode to generate a design doc from your code context, refine it, and hand the ticket to coding agent.
  • Fix regressions with agent mode: If coding agent's pull request introduces a build failure, open the branch locally and have agent mode diagnose and patch it.

Quality and Safety Considerations

  • Rely on tests: Both agents need coverage; without it they operate with little useful feedback.
  • Protect secrets: Coding agent runs in a secure ephemeral environment, but still guard .env files.
  • Review all output: Agents accelerate work; they do not eliminate your responsibility as reviewer.
  • Use branches locally: Agent mode edits in place, so commit early and often to keep your working tree recoverable.

Common Questions

Can coding agent handle legacy Perl code? It can attempt it, but without tests it may struggle. Use agent mode to refactor first.

Does agent mode support vim? Not yet. Modal editing remains available in VS Code itself.

How many issues can coding agent handle at once? Multiple, but each consumes compute and adds to your PR queue. Scale according to your tolerance.

Does coding agent work with images? Yes. Vision models let it interpret screenshots or mockups included in GitHub issues.

Can coding agent access external data sources? Yes, via Model Context Protocol (MCP) support it can connect to capabilities beyond GitHub.

The Practical Takeaway

Agent mode handles synchronous work in your editor; coding agent handles asynchronous work in issues and pull requests. Clear prompts, solid test coverage, and appropriately scoped tasks remain the fundamentals that make either agent perform well. Used together, they cover the full dev cycle—from exploratory "what if" through review and merge—while leaving architecture decisions, security reviews, and final judgment in human hands. Agents handle the routine parts; the interesting engineering stays with you.