VS Code Multi-Agent Development: Running Claude, Codex, and Copilot Together

What Changed in VS Code 1.109

Microsoft announced VS Code 1.109 on February 4, 2026 with the tagline "Your Home for Multi-Agent Development." The release added three things that matter:

Before 1.109, running multiple agents meant switching between terminals, extensions, and chat interfaces. The Agent Sessions view consolidates everything into one panel. You see every active session, its status, and its agent type. Switch between them with a click.

What Each Agent Does Best

These three agents are not interchangeable. Each has architectural strengths that make it the right choice for specific tasks. Running all three is not about redundancy. It is about matching the tool to the work.

Setup: 3 Agents in 5 Minutes

All three agents install as VS Code extensions. You do not need to configure anything beyond authentication to get started.

Step 1: Install Extensions

# Install via VS Code CLI (or search the Extensions panel)
code --install-extension GitHub.copilot
code --install-extension anthropic.claude-code
code --install-extension openai.chatgpt

Step 2: Authenticate

Each extension has its own authentication flow:

• Copilot: Sign in with your GitHub account. Copilot activates automatically if you have an active subscription.
• Claude Code: Open the extension panel and sign in with your Anthropic account (Pro, Max, Team, or Enterprise). You can also use API credits by entering an API key.
• Codex: Sign in with your ChatGPT account. Cloud agent features require Copilot Pro+ or Enterprise.

Step 3: Verify in Agent Sessions

Open the Agent Sessions view from the sidebar (or Cmd+Shift+P > "Agent Sessions"). You should see all three agents available as session types when you create a new session.

{
  // Enable agent mode for Copilot
  "github.copilot.chat.agent.enabled": true,

  // Claude Code settings
  "claude-code.enableAutoAccept": false,
  "claude-code.showInlineDiffs": true,

  // Codex settings
  "codex.defaultMode": "agent",
  "codex.reasoningEffort": "high",

  // Agent Sessions view orientation
  "chat.agentSessions.orientation": "side-by-side"
}

Parallel Sessions: Running Multiple Agents at Once

The Agent Sessions view is where multi-agent development gets practical. You can create sessions for different agents, run them in parallel, and switch between them without losing context.

Session Types

A common workflow: start a Copilot local session for interactive coding, fire off a Codex cloud session to scaffold a new module in the background, and keep a Claude session open for architectural questions. All three appear in the Agent Sessions panel. When the Codex cloud session finishes, you get a notification and can review the diff.

Subagents

VS Code 1.109 introduced parallel subagents. When an agent needs to perform multiple independent analyses, it can spawn subagents that each get their own context window. The main agent waits for all subagents to complete, then aggregates results.

// When you ask an agent:
// "Analyze this PR for security, performance, and accessibility issues"

// VS Code spawns 3 subagents in parallel:
// Subagent 1: Security analysis  → own context window
// Subagent 2: Performance review → own context window
// Subagent 3: Accessibility audit → own context window

// Each subagent operates independently.
// Results merge back to the main agent when all complete.
// Your primary context stays clean — subtask tokens
// do not pollute the main conversation.

Configuration for Multi-Agent Workflows

Each agent has its own configuration surface. The settings below optimize for multi-agent usage specifically.

Copilot: Agent Skills

Agent Skills (GA in 1.109) let you package domain expertise into reusable instruction sets. Create a .github/copilot/skills/ folder in your repo with markdown files containing tested instructions for specific tasks: testing strategies, API design patterns, security review checklists.

---
name: Security Review
description: Review code changes for OWASP Top 10 vulnerabilities
---

## Instructions

When reviewing code for security:

1. Check all user inputs for injection vulnerabilities (SQL, XSS, command)
2. Verify authentication checks on every route handler
3. Look for hardcoded secrets or credentials
4. Check for proper CORS configuration
5. Verify rate limiting on public endpoints

Report findings as: [CRITICAL], [HIGH], [MEDIUM], [LOW]
Include the file path and line number for each finding.

Claude Code: CLAUDE.md + MCP

Claude Code reads a CLAUDE.md file in your project root for project-specific instructions. Combined with MCP servers, Claude can access external tools (databases, APIs, file systems) directly from VS Code.

# Project Context

## Stack
- Next.js 15, App Router, TypeScript
- PostgreSQL with Drizzle ORM
- Tailwind CSS

## Conventions
- Server components by default
- Server actions for mutations
- All DB access through Drizzle in server components

## Commands
- bun run dev: development server on port 3000
- bun run build: production build
- bun run typecheck: type checking

Codex: Autonomy Modes

Codex offers three autonomy levels in VS Code: Chat (planning only, no file access), Agent (reads/writes files with permission), and Full Access (no permission prompts). For multi-agent workflows, Full Access mode on a cloud sandbox is the sweet spot: fast, autonomous, and isolated from your local filesystem.

# Project-level Codex configuration
[agent]
mode = "agent"              # chat | agent | full-access
reasoning_effort = "high"   # low | medium | high

[sandbox]
environment = "cloud"       # local | cloud
writable_paths = ["src/", "tests/"]
read_only_paths = ["config/", "docs/"]

Multi-Agent Workflows That Work

Running three agents simultaneously is not useful by itself. The value comes from assigning the right agent to the right task based on its architectural strengths.

Workflow 1: Parallel Feature Development

Workflow 2: Debug + Fix + Test

When tracking down a bug across multiple files:

1. Claude session: Paste the error trace and ask Claude to identify the root cause. Its large context window lets it read all the relevant source files at once.
2. Copilot inline: Once Claude identifies the fix, use Copilot to implement it inline. Copilot's autocomplete is faster for targeted edits.
3. Codex cloud session: Send Codex to write regression tests for the fix in a cloud sandbox. It can run the tests in the sandbox to verify they pass.

Workflow 3: Large Codebase Refactoring

For refactoring across dozens of files, the multi-agent approach shines:

1. Claude with subagents: Ask Claude to analyze the codebase and create a refactoring plan. It can spawn subagents to analyze different modules in parallel.
2. Multiple Codex sessions: Create separate Codex cloud sessions for each independent module that needs changes. They execute in parallel, each in its own sandbox.
3. Copilot: Handle the glue code and integration points where the refactored modules connect. Copilot's context awareness of your current file makes it efficient for targeted adjustments.

VS Code Multi-Agent vs Cursor

Cursor is a VS Code fork that goes deep on a single-agent experience. VS Code goes wide with multi-agent orchestration. The right choice depends on which constraint matters more.

Cursor wins on inline experience. Tab completion, Composer for multi-file edits, and the tightly integrated agent mode feel more cohesive than VS Code's extension-based approach. If you primarily work with one model and value seamless inline integration, Cursor is the better choice.

VS Code wins on agent diversity and ecosystem. Running Claude for architecture, Codex for execution, and Copilot for autocomplete is a workflow Cursor cannot replicate. If you want to pick the right agent for each task rather than using one agent for everything, VS Code is where you do that. See our Claude Code vs Cursor comparison for more on single-agent trade-offs.

Performance: Running 3 Agents Without Melting Your Machine

Running multiple AI extensions simultaneously has real costs. Each agent extension maintains connections, processes events, and consumes memory. A few settings make the difference between smooth operation and a stuttering editor.

Memory and CPU

• Copilot: ~150-300 MB resident memory. Runs a language server process that stays active for autocomplete.
• Claude Code extension: ~100-200 MB. Spins up processes only during active sessions.
• Codex extension: ~100-200 MB. Cloud sessions offload computation to remote infrastructure.

Total overhead: 350-700 MB across all three. On a machine with 16 GB RAM, this is manageable. On 8 GB, you may want to disable agents you are not actively using.

Recommended Settings for Performance

{
  // Disable Copilot autocomplete when using agent sessions
  // (reduces background CPU from continuous completions)
  "github.copilot.enable": {
    "*": true,
    "plaintext": false,
    "markdown": false
  },

  // Limit background agent sessions
  "chat.agentSessions.maxBackgroundSessions": 2,

  // Prefer cloud sessions for Codex (offloads compute)
  "codex.preferCloudSessions": true,

  // Reduce Claude extension diagnostics sharing
  "claude-code.shareDiagnostics": false
}

Token Costs Across Agents

Running multiple agents means multiple subscription costs. The minimum viable multi-agent stack:

• GitHub Copilot: $10/mo (Individual) or $19/mo (Pro) for basic. $39/mo (Pro+) for cloud agents and Codex.
• Claude Code: $20/mo (Pro) for standard limits. $100/mo (Max 5x) or $200/mo (Max 20x) for heavy usage.
• Total minimum: $49-59/mo for Copilot Pro + Claude Pro. Add Pro+ for Codex cloud: $59-79/mo.

Frequently Asked Questions

Can I run Claude, Codex, and Copilot at the same time in VS Code?

Yes. VS Code 1.109 (January 2026) added first-party support for all three. Install the Claude Code extension and the OpenAI Codex extension alongside GitHub Copilot. Each runs in its own session within the unified Agent Sessions view. Parallel execution across all three is supported.

Do I need a Copilot Pro+ subscription for Codex?

Cloud-based Codex sessions require Copilot Pro+ ($39/mo) or Enterprise. The Codex extension installs and authenticates with any ChatGPT subscription, but cloud sandbox features need the higher tier. Claude Code is separate, requiring an Anthropic subscription.

What is the Agent Sessions view?

A unified panel that shows all active agent sessions: local, background, and cloud. You can create new sessions for any installed agent, switch between them, and monitor progress. Sessions can be displayed stacked, side-by-side, or hidden based on your preference.

Can VS Code agents run subagents in parallel?

Yes. Subagents are context-isolated agents that the main agent delegates work to. They run in their own context windows, so subtask tokens do not pollute the main conversation. When you request parallel analysis (e.g., "review security and performance simultaneously"), VS Code runs subagents concurrently.

How does this compare to Cursor?

Cursor provides a deeper single-agent experience with best-in-class Tab autocomplete and tightly integrated Composer mode. VS Code provides agent diversity: run Claude, Codex, and Copilot simultaneously for different tasks. Choose Cursor for seamless inline AI. Choose VS Code for multi-agent orchestration. See our detailed comparison.

What are Agent Skills?

Agent Skills are reusable instruction sets (markdown files in .github/copilot/skills/) that package domain expertise for Copilot. They contain tested instructions for specific tasks: testing strategies, API design, security review. Skills are generally available in VS Code 1.109 and enabled by default.