GitHub Agent HQ: Run Claude, Codex, and Copilot Together

You've been picking sides. Claude for reasoning. Copilot for autocomplete. Codex for autonomous tasks. But what if you didn't have to choose?

GitHub Agent HQ is a unified command center that lets you run multiple AI coding agents — Claude, Codex, and Copilot — directly inside GitHub, VS Code, and even your phone. Assign an issue to all three agents simultaneously, compare their pull requests side by side, and merge the best solution. No tab-switching. No copy-pasting between tools. Just one platform orchestrating your entire AI fleet.

This isn't theoretical. As of February 2026, Agent HQ is live in public preview for paid Copilot subscribers, and it's already changing how teams think about AI-assisted development. (Pricing and agent availability verified as of May 2026.)

GitHub Agent HQ is a unified control center for running multiple AI coding agents — Copilot, Claude, and Codex — together on your repositories from GitHub, VS Code, or your phone.

📋 What You'll Need

Before you start orchestrating multiple agents, make sure you have:

• GitHub account with an active Copilot subscription (Pro, Pro+, Business, or Enterprise)
• VS Code v1.109+ (for local and cloud agent sessions)
• At least one repository to connect agents to
• Claude and Codex enabled in your GitHub account settings (they're off by default)
• An AGENTS.md file (optional but highly recommended — we'll cover this below)

🏗️ What Is GitHub Agent HQ?

Agent HQ is GitHub's answer to the multi-agent chaos problem. Instead of running Claude Code in one terminal, Copilot in your editor, and Codex in another browser tab, Agent HQ gives you a single interface — called Mission Control — to assign, monitor, and steer every agent from anywhere.

Think of it as air traffic control for AI agents. Each agent is a plane. Mission Control prevents collisions, manages takeoff order, and makes sure everyone lands safely.

How it works under the hood

┌──────────────────────────────────────────────────────┐
│                   Mission Control                     │
│                                                       │
│  ┌─────────┐   ┌─────────┐   ┌─────────┐            │
│  │ Copilot │   │ Claude  │   │  Codex  │   + more   │
│  └────┬────┘   └────┬────┘   └────┬────┘            │
│       │              │              │                 │
│       ▼              ▼              ▼                 │
│  ┌──────────────────────────────────────────┐        │
│  │           Your Repository                 │        │
│  │  Issues → Agent Work → Draft PRs → Review │        │
│  └──────────────────────────────────────────┘        │
└──────────────────────────────────────────────────────┘

Agents operate inside your existing Git workflow. They read issues, write code in branches, submit draft pull requests, and respond to @mentions in PR comments. Their output goes through the same review process as human contributions — no special tooling required.

What each agent brings to the table

The real power isn't in any single agent — it's in comparing how they approach the same problem and picking the best solution.

⚡ GitHub Agent HQ Setup: Getting Started

Setting up Agent HQ takes about five minutes. Here's the step-by-step.

Step 1: Check your subscription

Agent HQ requires a paid Copilot plan. Here's what's available:

Each agent session consumes one premium request from your monthly quota. A "session" is one task assignment — whether that's fixing a bug, writing tests, or reviewing a PR.

Step 2: Enable Claude and Codex

Claude and Codex are not enabled by default. You need to opt in:

1. Go to github.com → Settings → Copilot
2. Find the Agent access section
3. Toggle on Claude by Anthropic and OpenAI Codex
4. Accept the terms for each provider

For Business/Enterprise admins: Use the Control Plane to set organization-wide policies for which agents are permitted.

Step 3: Open Mission Control

You can access Mission Control from three places:

• GitHub.com: Navigate to any repository → click the Agents tab
• VS Code: Open the Command Palette (Ctrl+Shift+P) → search "Copilot Agent"
• GitHub Mobile: Tap the Copilot icon → select an agent

Step 4: Assign your first task

The simplest way to start:

1. Open an issue in your repository
2. In the Assignees dropdown, select @Copilot, @Claude, or @Codex
3. The assigned agent begins working and submits a draft PR when done
4. Review the PR like you would any human contribution

You can assign multiple agents to the same issue to compare their approaches.

📝 AGENTS.md: Configuring Your AI Team

If you've used a CLAUDE.md project instructions file, AGENTS.md will feel familiar. It's a markdown file in your repository root that tells agents how to behave — your project's rules, tech stack, build commands, and boundaries.

GitHub analyzed over 2,500 public AGENTS.md files and found that the most effective ones share a consistent structure.

Basic AGENTS.md template

# AGENTS.md

## Project Overview
E-commerce API built with Node.js 20, TypeScript, PostgreSQL, and Redis.
Monorepo managed with Turborepo.

## Build & Test Commands
- Install: `pnpm install`
- Build: `pnpm turbo run build`
- Test: `pnpm turbo run test`
- Lint: `pnpm turbo run lint`

## Code Style
- Use TypeScript strict mode
- Prefer named exports over default exports
- Use Zod for runtime validation
- Error handling: throw typed errors, never return null for failures

## Architecture
- `/packages/api` — Express REST API
- `/packages/db` — Prisma schema and migrations
- `/packages/shared` — Shared types and utilities
- `/packages/web` — Next.js frontend

## Testing Standards
- Unit tests with Vitest
- Integration tests use test database (see `.env.test`)
- Minimum 80% coverage for new code
- Always test error paths, not just happy paths

## Boundaries
✅ Always: Run tests before submitting PRs
✅ Always: Follow existing naming conventions
⚠️ Ask first: Database schema changes
⚠️ Ask first: Adding new dependencies
🚫 Never: Modify `.env` files or secrets
🚫 Never: Force push or delete branches
🚫 Never: Auto-merge without human review

Why AGENTS.md matters

Without it, every agent session starts from scratch — the agent has to figure out your build system, test runner, and coding conventions by reading your entire codebase. With a good AGENTS.md, agents hit the ground running.

You can also place directory-level AGENTS.md files in subpackages. Agents automatically read the nearest one in the directory tree, so your frontend package can have different rules than your API.

Creating custom agent personas

Beyond the root AGENTS.md, you can define specialized agents in .github/agents/:

---
name: test-agent
description: Writes unit and integration tests for new code
---

# Test Agent

You are a testing specialist. Your job is to write comprehensive
tests for code changes.

## Rules
- Use Vitest for unit tests, Playwright for E2E
- Test error paths and edge cases, not just happy paths
- Never modify source code — only add test files
- Run the full test suite before submitting

This creates a @test-agent you can mention in issues and PRs. GitHub's research identified six common agent archetypes that work well:

🚀 Multi-Agent Workflows That Actually Work

Running multiple agents sounds great in theory. In practice, you need strategy. Here's what works — and what causes chaos.

Pattern 1: Parallel independent tasks

The easiest win. Assign different agents to tasks that don't touch the same files:

Issue #42: "Add rate limiting to /api/users" → assign @Codex
Issue #43: "Write docs for auth endpoints"   → assign @Claude
Issue #44: "Fix flaky test in checkout flow"  → assign @Copilot

Each agent works in its own branch. No merge conflicts. No coordination needed.

Pattern 2: Competitive comparison

Assign the same issue to multiple agents and compare results:

Issue #45: "Refactor the payment service to use the strategy pattern"
  → assign @Claude, @Codex, @Copilot

You'll get three draft PRs with three different approaches. Review each one, pick the best, and close the rest. This is especially valuable for architectural decisions where you want to see multiple perspectives.

Pattern 3: Pipeline (sequential handoff)

Use agents in sequence, where each one builds on the previous:

1. @Claude — Analyze the issue and create an implementation plan (PR comment)
2. @Codex — Implement the plan (draft PR with code)
3. @test-agent — Write tests for the implementation (follow-up PR)

You steer between steps by commenting on the PR: @Codex implement the approach Claude outlined above.

What to run in parallel vs. sequentially

🖥️ VS Code Agent Sessions: Local, Cloud, and Background

VS Code v1.109 introduced three types of agent sessions, each suited for different workflows.

Local sessions

Run the agent interactively inside your editor. Fast feedback loop, direct access to your local environment.

Best for: Quick edits, inline suggestions, debugging with local context.

Ctrl+Shift+P → "Copilot: Start Agent Session" → Local

Cloud sessions

Delegate the task to GitHub's infrastructure. The agent runs autonomously on GitHub's servers, accesses your repo, and submits results as a draft PR.

Best for: Autonomous tasks you don't need to babysit. Assign before lunch, review after.

Background sessions

Asynchronous local work. The agent runs in the background while you continue coding — no context switching.

Best for: Long-running tasks like test generation or documentation updates.

Monitoring agent sessions

Mission Control shows real-time logs of what each agent is doing and why. Watch for these red flags:

• Failing tests repeatedly — the agent might be stuck in a loop
• Unexpected files in the diff — scope creep beyond the assigned task
• Circular behavior — same action attempted multiple times

When you spot issues, intervene with a specific comment: "Don't modify database.js — that file is shared across services. Add the config in api/config/db-pool.js instead."

🛡️ Why Multi-Agent Workflows Fail (And How to Fix It)

GitHub published a detailed analysis of multi-agent failures. The core insight: treat agents like distributed systems, not chat flows.

Failure #1: Messy data exchange

Agents pass information to each other through PR comments and code. Without structure, things break fast — one agent formats a response as JSON, another expects plain text.

Fix: Use typed schemas. Define exactly what each agent should output. If you're building custom agents, use Model Context Protocol (MCP) to enforce input/output contracts.

Failure #2: Conflicting actions

One agent closes an issue that another agent just opened. Or two agents edit the same file and create an unresolvable merge conflict.

Fix: Partition work clearly. Assign each agent to a specific module, directory, or file set. Use your AGENTS.md boundaries to prevent overlap.

Failure #3: Scope creep

You asked the agent to fix a bug. It "helpfully" refactored the entire module, broke three tests, and added a dependency.

Fix: Set explicit boundaries in AGENTS.md using the three-tier system:
- ✅ Always do: Run tests, follow conventions
- ⚠️ Ask first: Schema changes, new dependencies
- 🚫 Never do: Force push, modify secrets, auto-merge

Failure #4: Blind trust

Agent output looks clean, passes CI, and the PR description is well-written. So you merge without reading the code. Two weeks later, you discover a subtle bug.

Fix: Review agent PRs with the same rigor you'd apply to a junior developer's code. Agents can make mistakes — and their mistakes are often confident-looking.

💰 GitHub Agent HQ Pricing Breakdown

Understanding the cost model is critical, especially if you're running multiple agents on every issue.

The real cost math

If you run three agents on every issue (the competitive comparison pattern), you're burning 3 premium requests per issue. On the Pro plan with 300 requests, that's only 100 issues per month — which might be tight for an active project.

Pro+ at 1,500 requests gives you 500 three-agent comparisons per month, which is plenty for most individual developers.

For teams: Business plan at 300/user means a team of 5 gets 1,500 total requests. But remember, agent sessions also consume GitHub Actions minutes, so factor that into your budget.

🔧 Troubleshooting Common Agent HQ Issues

Agent doesn't start working on an assigned issue

• Verify Claude/Codex are enabled in Settings → Copilot → Agent access
• Check that your subscription tier supports the agent you're trying to use
• Ensure you haven't exhausted your monthly premium requests
• Try unassigning and reassigning the agent

Agent produces low-quality code

• Add or improve your AGENTS.md with specific code style examples
• Include build and test commands so the agent can validate its own work
• Provide more context in the issue description — agents work better with detailed specs

Merge conflicts between agent PRs

• Partition work by module before assigning agents
• Avoid assigning multiple agents to issues that touch the same files
• Use the sequential pipeline pattern instead of parallel assignment

Agent gets stuck in a loop

• Check session logs in Mission Control for circular behavior
• Intervene with a specific comment steering the agent away from the failing approach
• Cancel the session and restart with a more constrained prompt

VS Code agent session won't connect

• Update VS Code to v1.109 or later
• Check that the GitHub Copilot extension is up to date
• Verify your authentication — sign out and sign back into GitHub

Frequently Asked Questions

What is GitHub Agent HQ?

Agent HQ is GitHub's unified command center (called Mission Control) for running multiple AI coding agents — Copilot, Claude, and Codex — on your repos from GitHub, VS Code, or mobile. You can assign one issue to several agents and compare their pull requests.

How much does GitHub Agent HQ cost?

It needs a paid Copilot plan: Pro ($10/mo, 300 premium requests), Pro+ ($21/mo, 1,500), Business ($19/user), or Enterprise ($39/user). Each agent session uses one premium request and also consumes GitHub Actions minutes.

Which agents can I run in Agent HQ?

Copilot (on by default), plus Claude and Codex once you enable them in Settings → Copilot → Agent access. Integrations for Google's Jules, Cognition's Devin, and xAI are on the way.

What is AGENTS.md?

A markdown file in your repo root that tells every agent your stack, build/test commands, code style, and boundaries — the multi-agent equivalent of CLAUDE.md. You can also add directory-level AGENTS.md files and custom agent personas in .github/agents/.

Can I run multiple AI agents on the same issue?

Yes. Assign one issue to Copilot, Claude, and Codex to get three draft PRs and pick the best (the competitive-comparison pattern). Partition work by file or module to avoid merge conflicts when running agents in parallel.

🔮 What's Next

GitHub Agent HQ is just the beginning of multi-agent development. Here's where things are heading:

• 🤖 More agents incoming — Google (Jules), Cognition (Devin), and xAI are building integrations for Agent HQ. By mid-2026, you'll have 6+ agents to choose from.
• 📊 Copilot Metrics Dashboard is in public preview — track which agents deliver the best results across your organization.
• 🔒 Enterprise governance is maturing fast, with audit logging, model access controls, and agent-level permissions for compliance-heavy teams.
• 🧩 MCP Registry in VS Code connects agents to external tools like Stripe, Figma, and Sentry — custom agents with specialized capabilities are getting easier to build.
• 📈 Gartner reports 1,445% growth in multi-agent system inquiries — this is becoming the default way teams work with AI, not the exception.

Already using GitHub Copilot? Read our GitHub Copilot Agent Mode Guide for single-agent workflows, or see how all the top AI coding tools compare in our AI Coding Agents Comparison.