Chat modes, Agent HQ, and execution contexts

Understand the four built-in chat modes, how Agent HQ provides unified session management, and how the three execution contexts (local, background, cloud) enable different work patterns.

Chat modes, Agent HQ, and execution contexts

GitHub Copilot isn’t a single-mode tool. It offers multiple ways to interact — from quick Q&A to autonomous multi-file refactoring — and multiple places to run that work — from your local VS Code window to a cloud agent that creates pull requests overnight. Understanding these modes and contexts helps you choose the right approach for each task.

This article explains the four built-in chat modes, the Agent HQ unified management interface, and the three execution contexts that determine where and how your agent sessions run.

Table of contents

• 🎯 The four chat modes
• 🏗️ Agent HQ: unified session management
• 🖥️ Execution contexts: local, background, and cloud
• 🌳 Work tree isolation
• 📋 Plan → agent delegation workflow
• ✅ Choosing the right mode and context
• 🎯 Conclusion
• 📚 References

---

🎯 The four chat modes

GitHub Copilot Chat provides four built-in chat modes, accessible via the mode picker in the chat input. Each mode defines a different level of autonomy and capability:

Mode	What it does	Can edit files?	Best for
Agent	Autonomous mode — determines necessary changes and applies them	Yes	Complex multi-file refactoring, feature implementation
Plan	Creates detailed implementation plans without modifying files	No (read-only)	Architecture planning, understanding approach before execution
Ask	Q&A mode for questions without file modifications	No	Learning, code explanations, debugging assistance
Edit	Direct code editing for targeted changes	Yes	Quick fixes, single-file modifications

How modes supersede custom patterns

Before these built-in modes existed, developers created complex multi-phase agent patterns — a “research” agent that gathered context, a “planner” agent that created a plan, and an “implementer” agent that made changes. The built-in modes now handle the most common version of this workflow natively:

1. Use Plan mode to analyze the problem and generate an implementation plan
2. Review and refine the plan
3. Use Agent mode (or delegate to background/cloud) to execute

This doesn’t eliminate the need for custom agents — specialized personas, tool restrictions, and domain-specific workflows still require .agent.md files. But for the general “think, then do” pattern, built-in modes are simpler and more reliable.

When to use each mode

Agent mode — your default for getting work done. The model reasons autonomously, searches your codebase, edits files, runs commands, and validates results. Use it when you want Copilot to complete a task end-to-end.

Plan mode — use before committing to a large change. Plan mode generates a structured approach without making any modifications. It’s particularly valuable for complex refactoring where you want to understand the scope before starting.

Ask mode — use for learning and exploration. Ask mode answers questions about your codebase, explains how code works, and discusses architecture decisions — all without touching any files.

Edit mode — use for focused, single-file changes. Edit mode is faster than Agent mode for simple tasks because it doesn’t need to reason about multi-step workflows.

---

🏗️ Agent HQ: unified session management

Agent HQ is the centralized interface for managing all agent sessions across execution contexts. Introduced in VS Code 1.107, it provides visibility and control over local, background, and cloud sessions from a single view.

What Agent HQ shows

• Recent sessions list — all local, background, and cloud sessions with filtering and search
• Session state indicators — read/unread markers, input-required flags, completion status
• Quick actions — archive, continue, copy workspace changes, delegate to different context

Session management features

Feature	Description
Side-by-side view	Agent sessions default to side-by-side layout for easier comparison
Input-required markers	Sessions needing user input are clearly flagged
Workspace copying	Copy workspace changes when creating background sessions
Persistent chat prompt	Chat prompt isn’t cleared when creating a new session
Collapsed tool calls	Tool calls in cloud sessions are collapsed by default

Agent HQ is particularly valuable when running multiple sessions in parallel — you can have a background agent refactoring your test suite while you interact with a local agent on a different feature, and track both sessions from the same interface.

---

🖥️ Execution contexts: local, background, and cloud

Every agent session runs in one of three execution contexts. The choice of context determines where code runs, how isolation works, and what integration model applies.

┌─────────────────────────────────────────────────────────────────┐
│                    EXECUTION CONTEXTS                           │
├──────────────────┬──────────────────┬───────────────────────────┤
│                  │                  │                           │
│  LOCAL           │  BACKGROUND      │  CLOUD                    │
│                  │                  │                           │
│  Interactive     │  Autonomous      │  Async (GitHub)           │
│  Same window     │  Git work tree   │  Creates PRs              │
│  Blocks UI       │  Non-blocking    │  Team collaboration       │
│                  │                  │                           │
│  Best for:       │  Best for:       │  Best for:                │
│  • Quick fixes   │  • Long tasks    │  • Overnight work         │
│  • Iterative     │  • Parallel      │  • Complex refactors      │
│    work          │    exploration   │  • Team review            │
│                  │  • Large changes │                           │
└──────────────────┴──────────────────┴───────────────────────────┘

Local agents

The most familiar context. The agent runs in your current VS Code window, interacting with your workspace directly.

Aspect	Description
Execution	Interactive, in the current window
Isolation	None — shares your workspace and files
Visibility	Full — you see every tool call and result
Blocking	Yes — the chat panel is occupied
Best for	Quick tasks, iterative debugging, guided exploration

Local agents are ideal when you need tight feedback loops — you’re working alongside the agent, reviewing each step, and steering the conversation.

Background agents

Background agents run autonomously using Git work trees for complete isolation.

Aspect	Description
Execution	Autonomous, in a separate Git work tree
Isolation	Full — uses an isolated work tree, no interference with your files
Visibility	Via Agent HQ — check progress, review changes
Blocking	No — you keep working while the agent runs
Best for	Long-running tasks, parallel exploration, large refactoring

Background agents are the key productivity multiplier — you can launch three agents exploring different approaches to the same problem, continue your own work, and review results when they’re done.

Cloud agents (GitHub Copilot coding agent)

Cloud agents run on GitHub’s infrastructure and create pull requests with their changes.

Aspect	Description
Execution	On GitHub’s servers, asynchronous
Isolation	Full — separate branch, separate environment
Visibility	Via GitHub PR — standard code review workflow
Blocking	No — completely async
Best for	Overnight work, complex refactoring, team review

Cloud agents integrate into your team’s existing PR workflow — changes go through code review, CI runs, and standard approval processes.

---

🌳 Work tree isolation

Background agents use Git work trees for complete isolation from your main workspace. This is a critical architecture detail that enables safe, parallel agent execution.

How it works

1. REQUEST
   "Start background agent session"
        │
        ▼
2. WORK TREE CREATION
   Git creates isolated work tree:
   /repo/.git/worktrees/agent-session-xyz/
   • Full copy of current branch state
   • Independent staging area
   • No interference with main workspace
        │
        ▼
3. AGENT EXECUTION
   Agent works in isolated work tree:
   • Makes changes without affecting your files
   • Can run tests and builds in isolation
   • Session visible in Agent HQ
        │
        ▼
4. REVIEW & INTEGRATE
   User reviews in Agent HQ:
   • "Direct Apply" → merges to your workspace
   • "Create PR" → pushes for team review
   Work tree cleaned up after integration

Why work tree isolation matters

Benefit	Description
No conflicts	Agent changes don’t interfere with your local uncommitted work
Parallel exploration	Run multiple agents exploring different approaches simultaneously
Safe experimentation	Agent can make breaking changes without affecting your environment
SCM integration	Changes appear in Source Control view with clear session attribution

Without work tree isolation, running a background agent would risk modifying files you’re actively editing. With isolation, your workspace stays untouched until you explicitly choose to integrate the agent’s changes.

---

📋 Plan → agent delegation workflow

One of the most powerful patterns combines Plan mode with agent delegation:

1. PLAN MODE
   "Plan authentication refactoring"
   
   Copilot generates detailed plan:
   • Step 1: Extract auth middleware
   • Step 2: Create token service
   • Step 3: Update route handlers
   • Step 4: Add unit tests
        │
        ▼
2. REVIEW
   You review the plan, refine if needed
        │
        ▼
3. DELEGATE
   "Start Implementation" button appears
   
   Choose execution context:
   ○ Local agent (interactive)
   ○ Background agent (work tree)
   ○ Cloud agent (GitHub PR)

This pattern gives you control over the approach (Plan mode) while leveraging automation for execution (Agent mode in any context). It’s especially valuable for complex changes where you want human judgment on the strategy before autonomous execution begins.

Entry points for delegation

You can delegate to different agent contexts from multiple places:

• Chat view — “Continue in…” button in chat response
• Agent HQ — session actions menu → “Continue as…”
• Command Palette — “GitHub Copilot: Start Background Session”
• Untitled prompt files — “Continue in…” button when drafting prompts

---

✅ Choosing the right mode and context

Mode selection

What do you need?
│
├─ Understand code or architecture
│   └─ Ask mode
│
├─ Plan a complex change before doing it
│   └─ Plan mode → then delegate to Agent
│
├─ Make a quick, single-file edit
│   └─ Edit mode
│
└─ Complete a task end-to-end
    └─ Agent mode

Context selection

How should the work run?
│
├─ Interactive, with tight feedback loops
│   └─ Local agent
│
├─ Long-running, keep working meanwhile
│   └─ Background agent (work tree)
│
└─ Async, team review, overnight
    └─ Cloud agent (GitHub PR)

Combined decision table

Scenario	Mode	Context
“Fix this typo”	Edit	Local
“Explain how auth works”	Ask	Local
“Plan database migration”	Plan	Local
“Implement the migration plan”	Agent	Background
“Refactor test suite”	Agent	Background (parallel)
“Add new feature for next sprint”	Agent	Cloud
“Explore three approaches to caching”	Agent	Background (×3, parallel)
“Quick iterative debugging”	Agent	Local

---

🎯 Conclusion

Chat modes, Agent HQ, and execution contexts form the interaction layer of GitHub Copilot. Modes control what kind of work happens (ask, plan, edit, or autonomous). Execution contexts control where that work runs (locally, in a background work tree, or on GitHub’s cloud). Agent HQ ties everything together with unified session management.

Key takeaways

• Four chat modes provide different autonomy levels: Agent (autonomous editing), Plan (read-only planning), Ask (Q&A), Edit (focused changes)
• Built-in modes supersede many custom multi-phase patterns — “Plan then Agent” replaces the common “research → plan → implement” workflow
• Agent HQ provides centralized management of all sessions across contexts
• Three execution contexts determine where work runs: local (interactive), background (work tree isolation), cloud (GitHub PRs)
• Work tree isolation enables safe, parallel background agent execution without interfering with your workspace
• Plan → delegate is a powerful pattern: plan with human judgment, execute with agent automation
• Context selection depends on your need for interactivity, parallelism, and team collaboration

Next steps

• Understanding agents, invocation, handoffs, and subagents — the customization layer that builds on top of these modes
• How Copilot assembles and processes prompts — how your chat mode and context affect prompt assembly
• How to design orchestrator prompts — advanced workflows that leverage multiple modes and contexts

---

📚 References

VS Code Copilot Chat Overview [📘 Official] Microsoft’s documentation for Copilot Chat modes, including Agent, Plan, Ask, and Edit modes with usage guidance.

VS Code Agent HQ Documentation [📘 Official] Official documentation for Agent HQ — unified session management, execution contexts, work tree isolation, and delegation workflows.

VS Code v1.107 Release Notes [📘 Official] December 2024 release introducing Agent HQ, background agents with work tree isolation, cloud agent integration, and the Plan mode → delegation workflow.

GitHub Copilot Coding Agent [📘 Official] GitHub’s documentation for the cloud execution context — the Copilot coding agent that creates pull requests from issues and natural language task descriptions.

---