A Copilot-first guide & configuration system for GitHub Copilot CLI
Agents · Skills · Rules · Multi-AI Orchestration
everything-copilot-cli is a Copilot-first operating kit for AI-assisted software delivery on GitHub.
This repository is built around three ideas:
- GitHub as the system of record — Issues, PRs, Actions, and code search are first-class inputs, not afterthoughts
- Copilot CLI as the orchestration hub — the coordination layer that routes tasks to the right model or agent and synthesizes results back through GitHub
- Model choice as a routing decision — GPT, Claude, and Gemini each have strengths inside Copilot; external specialists like Codex CLI can be orchestrated when a separate tool is the better fit
The result is a curated collection of agents, skills, rules, MCP configurations, and orchestration patterns — portable where possible, Copilot-native where it matters.
See Multi-AI Orchestration for how this repo's community patterns coordinate Claude Code, Codex CLI, Cursor CLI, and Antigravity CLI (
agy) as external specialist workers.
| Principle | What it means in practice |
|---|---|
| GitHub as system of record | Every workflow starts and ends in GitHub. Issues are task inputs. PRs are agent outputs. Actions are the observability layer. |
| Copilot CLI as orchestration hub | Copilot does not just generate code — it coordinates specialists. Claude reasons deeply, Codex generates fast, Cursor edits repos with IDE-shared context, Antigravity (agy) covers multi-model/multimodal analysis; Copilot routes and synthesizes. |
| Model choice is routing, not loyalty | No single model wins every task. Skills and patterns in this repo are designed to route work to the strongest model for each subtask. |
| Portable core, Copilot-native layer | Most skills work in any agentskills.io-compatible runtime. Copilot-exclusive capabilities are clearly separated in skills/copilot-exclusive/ so you always know what depends on native Copilot features. |
Three capabilities make Copilot CLI a strong hub for multi-AI development workflows:
GitHub-native access — Copilot CLI ships with a built-in GitHub MCP server. Issues, PRs, Actions logs, and code search are structured tool calls, not scraped text. No extra GitHub integration layer is required.
Multi-model routing — Within Copilot CLI you can switch between model families such as GPT, Claude, and Gemini with /model or per-agent overrides in the same session. Use a premium reasoning model for architecture, a fast model for boilerplate, and a cheaper model for triage.
Orchestration primitives — Plan Mode, Autopilot, Fleet, Background Delegation, and the built-in SQLite session database give you building blocks for complex multi-agent workflows. When a separate specialist tool is the better fit, this repository's orchestration patterns show how to delegate to Codex CLI, Claude Code, Cursor CLI, or Antigravity CLI (agy) and bring the result back through GitHub.
Full capability reference (11 features)
| # | Advantage | Description |
|---|---|---|
| 1 | GitHub-Native Integration | Issues, PRs, Actions, code search — all via built-in MCP. No extra setup. |
| 2 | 20+ Model Selection | GPT, Claude, Gemini families (example tiers, not exhaustive) — pick the right model per task. Check /model for the current roster since it changes over time. |
| 3 | IDE ↔ CLI Seamless Switching | Same Copilot context in VS Code, JetBrains, and the terminal. |
| 4 | Plan Mode | Structured text planning — Copilot builds a step-by-step implementation plan before writing any code. |
| 5 | Autopilot Mode | Autonomous task execution with guardrails. (Experimental) |
| 6 | Background Agents | Delegate to cloud Copilot agents via & or /delegate; resume anytime with /resume. |
| 7 | Fleet Mode | Parallel agent execution — split work across multiple agents simultaneously. |
| 8 | Session SQL Database | Built-in SQLite per session for structured data, todo tracking, and state. |
| 9 | Cross-Session Memory | Search and reuse prior session history via session_store. |
| 10 | LSP First-Class Support | Language Server Protocol integration for precise code intelligence. |
| 11 | Multi-AI Orchestrator | Orchestrate Claude Code, Codex, Cursor CLI, Antigravity (agy) from Copilot as the meta-hub (community pattern). |
# 1. Install GitHub Copilot CLI
npm install -g @github/copilot
# 2. Clone this repository
git clone https://github.com/drvoss/everything-copilot-cli.git
cd everything-copilot-cli
# 3. Verify the cloned repository
npm install && npm run setup
# 4. Install the collection into your project
npm run setup -- --target /path/to/your-projectThe first command runs a quick verification for the documented clone + setup flow. The second command is also run from this repository root and installs into the project path passed through --target.
During step 4, setup offers these profiles:
| Profile | Recommended? | Installs |
|---|---|---|
minimal |
For light touch onboarding | .github/copilot-instructions.md only |
recommended |
Yes | Starter instructions, agents, skills, and rules |
full |
For advanced setups | Everything, including contexts |
custom |
When you want full control | Lets you choose each component with explanations |
Setup writes project instructions to .github/copilot-instructions.md, installs custom agents to .github/agents/, project skills to .github/skills/, and rules to .github/copilot/rules/. The full profile also installs contexts to .github/copilot/contexts/.
This repository's npm run setup path is still the fastest way to install the full profile in one pass. If you only want to add or remove individual skills, GitHub Copilot CLI v1.0.72+ also supports native skill management:
# Install a skill from a local file into this repository
copilot plugins install --skill ./skills/development/fix-build-errors/SKILL.md --scope project
# Install a skill from a URL into this repository
copilot plugins install --skill https://example.com/path/to/SKILL.md --scope project
# Install a skill from a local directory
copilot plugins install --skill ./skills/development/fix-build-errors
# Remove an installed skill by name
copilot plugins remove --skill fix-build-errorsUse npm run setup when you want this repository's instructions, rules, contexts, agents, and skills installed together. Use the native copilot plugins install/remove --skill commands when you want to manage one skill at a time through the CLI. The --scope project flag is documented for file and URL installs into the repository; the directory example above intentionally omits that flag.
Then open a terminal and start using Copilot CLI with the installed agents, skills, and rules:
# Start a session in your project directory
cd your-project
copilotAfter copilot starts, you can quickly check whether the installation was picked up:
- The startup banner should mention your project custom instruction and show additional project skills and agents.
- `/instructions` should show the installed project instructions.
- `/skills` should show project skills, not just built-in ones.
- `/agent` should show custom agents such as `planner`.
- If you only see built-in skills and no project agents, the collection was not discovered in this repository yet.
# Use the planner agent (inside the session)
> Design a REST API for user management — use plan mode
# Run TDD workflow
> Add tests for the auth module using TDD
# Orchestrate multiple AIs
> Claude reasons architecture, Codex implements, Copilot reviews — delegate accordinglyFor detailed instructions, see the Quick Start Guide. Want a copy-paste beginner lab? Try the Beginner Skills Tutorial.
everything-copilot-cli/
├── agents/ # Agent definitions (8 core agents)
│ ├── planner.md
│ ├── architect.md
│ ├── code-reviewer.md
│ ├── security-reviewer.md
│ ├── tdd-guide.md
│ ├── build-error-resolver.md
│ ├── doc-updater.md
│ └── refactor-cleaner.md
│
├── skills/ # Reusable workflow skills (109 total)
│ ├── copilot-exclusive/ # ★ Copilot-only skills (26)
│ ├── development/ # Dev skills (25)
│ ├── documentation/ # Doc skills (6)
│ ├── security/ # Security skills (12)
│ ├── testing/ # Test skills (6)
│ ├── workflow/ # Workflow skills (26)
│ ├── product/ # Product skills (5)
│ └── content/ # Content & GEO skills (3)
│
├── rules/ # Coding rules & guidelines
│ ├── common/ # Universal rules (6)
│ ├── languages/ # Language-specific: TS, Python, Go, C#, Java, C++
│ └── frameworks/ # Framework rules (8)
│
├── orchestration/ # ★ Multi-AI Orchestration
│ ├── patterns/ # 11 orchestration patterns
│ ├── configs/ # MCP bridge configs
│ ├── skills/ # Orchestration skills (9)
│ ├── templates/ # Reusable orchestrator templates
│ └── examples/ # Real-world examples (6)
│
├── guides/ # 16 comprehensive guides
├── mcp-configs/ # MCP server configurations (7 files; 6 configs + README)
├── examples/ # Project-specific copilot-instructions
│ ├── nextjs-app/
│ ├── python-api/
│ ├── dotnet-webapp/
│ └── monorepo/
│
├── contexts/ # Context presets
├── references/ # Checklist & pattern references (14 files across root + subdirectories)
│ ├── github-actions-efficiency/ # Actions efficiency audit references
│ ├── github-codespaces-efficiency/ # Codespaces efficiency guidance
│ ├── security-scan/ # Stack-specific security guidance
│ ├── testing-patterns.md # AAA structure, mocking, component/API/E2E patterns
│ ├── security-checklist.md # OWASP Top 10, auth, input validation, security headers
│ ├── performance-checklist.md # Core Web Vitals, frontend/backend optimization
│ ├── accessibility-checklist.md # WCAG 2.1 AA, keyboard nav, screen reader, forms
│ └── ecosystem-monitoring-playbook.md # Monitoring cadence, prompt archetypes, adopt/adapt/reject output contract
├── scripts/ # Setup & migration tools
└── tests/ # Test suite
Pre-configured agent definitions — each with a specific role, system prompt, and tool set.
| Agent | Purpose |
|---|---|
| planner | Breaks tasks into structured plans with dependency tracking |
| architect | Designs system architecture and component boundaries |
| code-reviewer | Reviews code for bugs, logic errors, and security issues |
| security-reviewer | Focused security audit with OWASP/CWE classification |
| tdd-guide | Test-Driven Development workflow — red/green/refactor |
| build-error-resolver | Diagnoses and fixes build/compilation errors |
| doc-updater | Keeps documentation in sync with code changes |
| refactor-cleaner | Identifies and executes safe refactoring opportunities |
Reusable, composable workflows organized by category. All follow the agentskills.io spec.
★ Copilot-Exclusive Skills (26)
Skills that leverage capabilities unique to GitHub Copilot CLI:
| Skill | Description |
|---|---|
context-prime |
Load project context at session start (README, file tree, commits, stack) |
session-management |
Built-in SQLite for todo tracking and structured state |
plan-mode-mastery |
Structured text planning with approval workflow |
autopilot-patterns |
Autonomous execution with guardrails |
background-agent |
Delegate to cloud agents via & / /delegate |
fleet-parallel |
Parallel agent execution with /fleet |
github-code-search |
Search GitHub's global code index for real implementation examples and use the results as grounded context |
github-pr-workflow |
Full PR lifecycle via built-in GitHub MCP |
github-issue-triage |
Bulk issue classification and triage |
github-codespaces-efficiency |
Audit GitHub Codespaces startup time, machine sizing, prebuild scope, and spend without stripping required dev tools |
actions-debugging |
Debug CI failures with native Actions access |
cross-session-memory |
Search and resume prior session context |
copilot-memory |
Review and curate repository-level Copilot memory shared across CLI, cloud agent, and code review |
knowledge-curator |
Promote repeated lessons into durable project guidance |
mcp-builder |
Build a new MCP server with config validation and hot-reload |
multi-model-strategy |
Pick the right model per task |
mcp-ecosystem |
Extend with custom MCP servers |
ide-switching |
Seamless VS Code ↔ CLI context sharing |
scope-guard |
Lock a task to a narrow writable surface and add explicit stop rules for risky work |
team-planner |
Assemble specialist agent teams via SQL roster + /fleet dispatch |
agentic-engineering |
Design 15-min task units, eval-first loops, and explicit I/O contracts |
stack-detector |
Scan project tech stack and recommend relevant skills and rules from this collection |
task-intake-router |
Route incoming work to the right mode, agent type, model, and delegation path |
ecosystem-intake |
Convert curated ecosystem sources into adopt/adapt/reject backlog candidates |
sub-agent-sandboxing |
Constrain delegated work with loop thresholds, circuit breakers, and sandbox escalation before accepting output |
token-cost-optimizer |
Proactively reduce Copilot usage cost before large autonomous or parallel tasks |
Development Skills (25)
| Skill | Description |
|---|---|
api-and-interface-design |
Define public APIs, CLIs, webhooks, or SDK contracts before implementation |
tdd-workflow |
Red → Green → Refactor cycle |
code-review |
Structured review with severity levels |
cpp-debugging |
Use when a C++ failure involves memory lifetime, undefined behavior, native crashes, or debugger-only state — debug with symbols, sanitizers, and platform-native debuggers before patching symptoms |
fix-github-issue |
Read issue → locate bug → fix → test → PR |
implement |
Turn a PRD, spec, or set of issues into committed code via a five-step TDD → validate → review → commit loop |
fix-build-errors |
Diagnose and resolve build failures |
improve-codebase-architecture |
Use when a codebase feels hard to change, test, or navigate — surface architectural friction and walk one deeper-module candidate into a concrete refactoring direction |
performance-optimization |
Measure first, isolate bottlenecks, and prove performance improvements |
pr-multi-perspective-review |
6-lens PR review: PM / Dev / QA / Security / DevOps / UX |
review |
Compare changes against a pinned git reference on two separate axes: repository standards and originating spec |
receiving-code-review |
Verify review feedback against the codebase and push back with technical reasoning instead of performative agreement |
prototype |
Use when a design question is still fuzzy — build a throwaway logic or UI prototype that answers one question fast and is meant to be deleted or absorbed |
refactor-clean |
Remove dead code, simplify logic safely |
diagnose |
Build the fastest feedback loop first, rank the leading hypotheses, and instrument only what narrows the search |
source-driven-development |
Verify framework and library APIs against current official docs before implementing |
spec-driven-development |
Write a technical spec before coding — defines interface, structure, and boundaries first |
context-engineering |
Optimize information delivery to AI agents — minimize noise, maximize signal |
deprecation-and-migration |
Safely remove old APIs and migrate to new patterns with a 3-phase process |
skill-creator |
Describe a workflow → get a SKILL.md scaffolded in minutes |
systematic-debugging |
4-phase root cause analysis (reproduce → isolate → hypothesize → verify) before fixing |
zoom-out |
Step one abstraction level up from a local code detail, map owners and callers, and restate the system in project vocabulary |
Combo Skills (activate when two technologies are used together):
| Skill | Description |
|---|---|
nextjs-prisma |
Type-safe data fetching and Server Actions for Next.js App Router + Prisma projects |
react-vitest |
Component testing setup and patterns for React + Vitest projects |
nestjs-prisma |
PrismaService singleton, repository pattern, and unit testing for NestJS + Prisma |
Documentation Skills (6)
| Skill | Description |
|---|---|
add-to-changelog |
Keep a Changelog format, semver version sync |
doc-update |
Sync docs when implementation changes |
document-generate |
Create missing Diataxis documentation from scratch for a feature, module, or project |
api-documentation |
Generate and maintain API docs from source |
code-tour |
Generate VS Code CodeTour .tour files for codebase onboarding |
architecture-decisions |
Document hard-to-reverse technical decisions as Architecture Decision Records (ADRs) |
Security Skills (12)
| Skill | Description |
|---|---|
agent-owasp-check |
Audit an AI agent system against the OWASP Agentic Security Initiative Top 10 |
agent-governance |
Add policy controls, approval gates, trust scoring, and append-only audit trails to agent systems |
agent-supply-chain |
Verify integrity manifests, detect tampering, and enforce promotion gates for agent plugins and MCP bundles |
evaluate-repository |
7-dimension scorecard (1–10) with remediation plan |
gha-security-review |
Review GitHub Actions workflows for exploitable CI/CD attack paths such as pwn requests, expression injection, and credential escalation |
security-scan |
OWASP Top 10 + dependency audit |
secret-detection |
Find hardcoded secrets in source and git history |
input-validation |
Prevent injection attacks (SQL, XSS, CSRF) |
security-bounty-hunter |
Bug-bounty-perspective vuln hunting with proof-of-concept steps |
pr-security-review |
Automated PR security analysis — auth, injection, secrets, OWASP Top 10 |
threat-model-analyst |
Build or update a STRIDE-A threat model with trust boundaries, abuse cases, and change-focused findings |
mcp-implementation-security-review |
Review the source code of an MCP server or client implementation for auth, session, rate-limit, schema-validation, and SDK-usage vulnerabilities, with file/line-cited findings |
Workflow Skills (26)
| Skill | Description |
|---|---|
commit-workflow |
Conventional commits + emoji, atomic split guidance |
conventional-branch |
Create or validate Git branch names that follow a conventional type/description format before parallel work starts |
doubt-driven-development |
Challenge a non-trivial decision with a fresh-context adversarial review before it stands |
release |
tag → GitHub Release → publish (npm/PyPI/Docker) |
finishing-a-development-branch |
Verify tests, detect worktree state, then present merge/PR/keep/discard options and execute cleanup |
verification-before-completion |
Prove a task is done with fresh command output before claiming success |
sprint-workflow |
Full sprint: Think → Plan → Build → Review → Test → Ship → Monitor |
deployment-canary |
Post-release canary checks, rollback thresholds, and promote/hold decisions |
security-audit |
OWASP Top 10 + STRIDE threat modeling |
sprint-retro |
Data-driven retros using git metrics |
cost-audit |
Audit AI inference token spend and recommend model/prompt optimizations |
github-actions-efficiency |
Audit GitHub Actions workflows for CI minutes, caching, concurrency, trigger scope, and wasted runs |
council |
Convene a 4-voice adversarial decision council for high-stakes choices |
deep-research |
Systematic multi-source research with structured synthesis |
grill-me |
Stress-test a plan with one-question-at-a-time interrogation until assumptions, dependencies, and risks are explicit |
grill-with-docs |
Stress-test a plan against existing docs, glossary terms, and ADRs before implementation begins |
handoff |
Create a portable markdown handoff for the next session, agent, or machine without duplicating existing artifacts |
implementation-review |
Compare a delivered diff against the original task spec and produce actionable follow-up feedback |
interview-me |
Discover what the user actually wants before writing a plan, spec, or code |
llm-wiki |
Use when research or domain knowledge keeps getting rediscovered across sessions — build a supplementary markdown wiki that compounds synthesized knowledge without replacing GitHub or committed project guidance |
outside-voice |
Get an independent second opinion before, during, or after implementation with challenge, consult, and review modes |
prompt-optimizer |
Rewrite rough prompts into a finished, copy-pasteable prompt for chat-based LLMs with no placeholders |
to-issues |
Break a plan, spec, or PRD into thin dependency-aware issues that each deliver a verifiable vertical slice |
triage |
Use when a single issue needs structured triage — classify it, reproduce if needed, request missing information, and leave a durable brief or close-out note in the tracker |
using-git-worktrees |
Create isolated working directories for parallel branch work without recloning the repo |
wayfinder |
Use when a task is too large or ambiguous to finish in one session — build a destination-centric plan with breadth-first triage, an explicit Deferred section, and a confirmation gate before implementation starts |
Product Skills (5)
| Skill | Description |
|---|---|
create-prd |
JTBD-grounded PRD template |
feature-prioritization |
Impact × Confidence × Effort matrix |
opportunity-solution-tree |
Teresa Torres' OST framework |
launch-strategy |
Alpha → Beta → GA launch checklist |
product-capability |
Transform requirements into SRS-style capability specs with ACs and traceability |
Testing Skills (6)
| Skill | Description |
|---|---|
test-coverage |
Identify gaps and write targeted tests |
e2e-testing |
E2E test scaffolding for critical paths |
eval-harness |
Build LLM pipeline evaluation suites with SQL-tracked test cases |
qa-review |
Review QA strategy across test pyramid balance, test quality, reliability, and CI defect reporting |
browser-devtools |
Verify frontend behavior at runtime — DOM validation, network inspection, performance profiling |
ux-audit |
Structured usability review — quick scan (6 Krug checks) or deep audit (15-dimension Jobs/Ive framework) |
Content & Marketing Skills (3)
| Skill | Description |
|---|---|
ai-visibility |
GEO optimization: llms.txt, AI crawler access |
content-strategy |
Keyword research, topic clusters, content calendar |
seo |
Technical SEO audit: Core Web Vitals, structured data, crawl issues |
Coding rules and guidelines, organized by scope:
- Common Rules — Universal best practices (error handling, logging, naming conventions)
- Language-Specific Rules — TypeScript, Python, Go, C#, Java
- Framework-Specific Rules — Next.js, React, Vue, Prisma, Playwright, NestJS, Cloudflare Workers, Vitest
The Multi-AI Orchestration system (see dedicated section below).
| Guide | Description |
|---|---|
| Quick Start | Get up and running in 5 minutes |
| Shortform Guide | Concise reference for everyday use |
| Longform Guide | Deep dive into every feature |
| Security Guide | Security best practices and scanning |
| Copilot Exclusive Features | Features only available in Copilot CLI |
| Copilot vs Claude Code | Compare strengths, tradeoffs, and when to use each tool |
| Migration from Claude Code | Step-by-step migration path with concept mapping |
| Hooks to GitHub Actions | Claude Code Hooks alternatives (Git Hooks / Actions / Prompt Guards) |
| Orchestration Guide | Multi-AI orchestration patterns and setup |
| Skill Writing Best Practices | Write trigger-first descriptions that actually fire |
| Skill Testing Guide | Test trigger accuracy and output quality for promptware, with Promptfoo as an optional output-quality supplement |
| QA Agent Guide | Design QA agents that catch real bugs via boundary-crossing comparison |
| Beginner Skills Tutorial (EN) | Copy-paste lab to feel the difference between plain and skill-guided prompting |
| Beginner Skills Tutorial (KO) | Korean version of the beginner hands-on skills lab |
| Beginner Skills Tutorial (JA) | Japanese version of the beginner hands-on skills lab |
| Beginner Skills Tutorial (ZH) | Chinese version of the beginner hands-on skills lab |
All guides are in the guides/ directory.
Two layers — the distinction matters.
Copilot-native: GitHub MCP,
/modelswitching, Plan Mode, Autopilot, Fleet, Background Agents, and the session SQL database are built into Copilot CLI.Community pattern: cross-tool orchestration with Claude Code, Codex CLI, Cursor CLI, and Antigravity CLI (
agy) is documented in this repository as a shell/MCP/pipeline workflow pattern. It depends on those external CLIs being installed and is not an official built-in Copilot feature.
No single AI is best at everything. Claude excels at reasoning, Codex at rapid implementation, Cursor at repo-aware multi-file editing, Antigravity (agy) at multi-model/multimodal analysis, and Copilot at GitHub integration. What if you could use all of them from one place?
┌────────────────────────────────────────────────────────────────┐
│ GitHub Copilot CLI │
│ (Orchestrator / Meta-Hub) │
├────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ Claude Code│ │ Codex CLI │ │ Cursor CLI │ │ Antigravity│ │
│ │ (Reasoning)│ │(Impl./Gen.)│ │(Repo edits)│ │(agy·multi- │ │
│ │ │ │ │ │ │ │model/vision│ │
│ └────────────┘ └────────────┘ └────────────┘ └────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
| Pattern | How It Works | Best For |
|---|---|---|
| Shell Invocation | Copilot spawns other CLIs via shell commands | Simple delegation |
| MCP Bridge | Connect agents via Model Context Protocol servers | Structured tool sharing |
| Message IPC | Inter-process communication via files/pipes | Real-time collaboration |
| Pipeline | Chain agents sequentially — output of one feeds the next | Multi-stage workflows |
| Agent Council | Multiple agents deliberate and vote on decisions | Critical decisions |
| Pattern | How It Works | Best For |
|---|---|---|
| Fan-Out Parallel | Dispatch independent subtasks simultaneously | Batch operations |
| Producer-Reviewer | Iterative produce→review feedback loop | Artifact refinement |
| Hierarchical Delegation | Nested orchestrators (root→domain→specialists) | Large multi-domain tasks |
| Iterative Refinement | Self-correction loop with measurable exit criteria | Quality-sensitive generation |
| Review Trio | 3-way review for non-PR artifacts (RFC, schema, architecture) | Pre-publish review |
| Sub-Agent Sandboxing | Constrain delegated agents with worktree, scope, and permission boundaries | High-safety delegation |
Each AI tool in the orchestration ecosystem has a distinct specialization. Copilot CLI acts as the coordinator that brings them together:
| AI Tool | Specialization | Role in the Workflow |
|---|---|---|
| Copilot CLI | GitHub integration · multi-model flexibility · orchestration | Meta-hub / coordinator |
| Claude Code | Deep reasoning · large-context analysis | Reasoning specialist |
| Codex CLI | Rapid code generation · boilerplate | Implementation specialist |
| Cursor CLI | Repo-aware multi-file editing · IDE-shared context · headless JSON/CI | Repo-aware editor |
Antigravity CLI (agy) |
Multi-model backend (Gemini 3.x/Claude/GPT-OSS) · multimodal · Google grounding · background subagents | Multi-model / multimodal specialist |
The orchestration system is informed by real-world multi-agent frameworks:
- microsoft/autogen — Microsoft AutoGen framework
- crewAIInc/crewAI — CrewAI role-based agents
- langchain-ai/langgraph — LangGraph state machines
- geekan/MetaGPT — MetaGPT multi-agent SOP
- openai/swarm — OpenAI Swarm patterns
See the full Orchestration Guide for implementation details.
Copilot CLI is purpose-built around your GitHub workflow. Here's what you get out of the box:
| Capability | Details |
|---|---|
| GitHub-Native MCP | Issues, PRs, Actions, and code search — zero extra setup |
| 20+ Model Selection | Switch between GPT, Claude, Gemini families (example tiers) per task — check /model for the current roster |
| IDE ↔ CLI Context Sharing | Seamless switching between VS Code, JetBrains, and the terminal |
| Plan Mode | Structured text planning with approval workflow before any code is written |
| Autopilot Mode | Autonomous task execution with guardrails (Experimental) |
| Background Agents | Delegate to cloud agents via & / /delegate; resume with /resume |
| Fleet Mode | Parallel agent execution — split work across multiple agents simultaneously |
| Session SQL Database | Built-in SQLite per session for structured state and todo tracking |
| Cross-Session Memory | Search prior session history with session_store and /resume |
| LSP Integration | Language Server Protocol for precise, symbol-aware code intelligence |
| Multi-AI Orchestration | Coordinate Claude Code, Codex, Cursor CLI, Antigravity (agy) from a single hub (community pattern) |
See the Copilot Exclusive Features guide for a deep dive into each capability.
Coming from another AI coding tool? The skill format is nearly identical, so migration is straightforward:
CLAUDE.md rules → .github/copilot-instructions.md
.claude/commands/ → .github/skills/
.claude/settings.json → mcp-configs/ & contexts/
Claude Code Hooks → Git Hooks / GitHub Actions / Prompt Guards
The migration script automates most of the work:
node scripts/migrate-from-claude.js /path/to/your/projectSee the full Migration Guide and Hooks Alternatives Guide.
Contributions are welcome! Here's how you can help:
- Add agents — Define new agent roles in
agents/ - Create skills — Build reusable workflows in
skills/ - Write rules — Add coding guidelines in
rules/ - Share orchestration patterns — Contribute to
orchestration/ - Improve guides — Enhance documentation in
guides/ - Add examples — Show real-world setups in
examples/
# Install dependencies
npm install
# Validate configs
npm run validate
# Run tests
npm test
# Lint markdown
npm run lint:mdPlease read the existing guides and follow the established patterns before submitting a PR.
MIT © Everything Copilot CLI Contributors
Built for the GitHub Copilot CLI community
Acknowledges the pioneering work of everything-claude-code and awesome-claude-code