Less // TODO: more done with GitHub Copilot CLI

Key Concepts

• GitHub Copilot CLI: A feature-rich, agentic tool designed for terminal-based workflows.
• Headless Mode: Non-interactive execution for CI/CD pipelines and automation.
• Interactive Mode: A conversational state for back-and-forth engagement with the agent.
• Server Mode: Exposes a JSON RPC port to allow external applications to connect to the CLI programmatically.
• MCP (Model Context Protocol): A standard for connecting AI agents to external data sources and services.
• Multi-Agentic Architecture: A hierarchical system where a "main" agent delegates tasks to specialized sub-agents.
• Cross-Model Validation: Using different model families (e.g., Claude Sonnet + GPT) to improve accuracy and performance.

---

1. Getting Started with GitHub Copilot CLI

To utilize the CLI, users must have an active GitHub Copilot subscription. Installation methods vary by OS:

• Windows: Use winget or the Microsoft Store.
• macOS/Linux: Use Homebrew or npm.
• Authentication: Launch via the copilot command, then use /login to initiate the browser-based OAuth flow. Verify the active account with /user.

2. Interaction Modes

The CLI supports three distinct operational modes:

A. Headless Mode (Automation)

Designed for CI/CD workflows where the agent provides one-off outputs.

• Syntax: copilot -p "your prompt" or copilot --prompt "your prompt".
• Parameters: Use -s (silent) to suppress metadata and --no-ask to prevent clarifying questions.
• Application: Automating documentation generation (e.g., fetching GitHub changelogs for live streams) and injecting the output into markdown files or build pipelines.

B. Interactive Mode (Conversational)

The primary mode for manual development tasks.

• Slash Commands: Use / to access features like /models (to switch AI models), /env (to view customizations), and /skills (to manage scripts/instructions).
• Auto Mode: A system that evaluates model health and prompt complexity to automatically select the best model (e.g., GPT-5.3 Codex).
• Customization: Users can define custom agents via .agent.md files and manage MCP servers to pull in external context.

C. Server Mode (SDK Integration)

Allows developers to build AI-powered applications by connecting to the CLI via a JSON RPC port.

• Use Case: Building custom interfaces (e.g., an academic course management tool) that leverage the Copilot runtime for chat functionality, allowing users to resume CLI sessions directly within their own applications using /resume.

3. Advanced Agentic Features

• Built-in Agents:
  • Research Agent: Performs deep research on a topic and generates a report.
  • Plan Agent: Creates a structured implementation plan for systems or features.
  • Review Agent (/review): Analyzes local code changes for bugs and security vulnerabilities before pushing to GitHub.
  • Rubber Duck Agent: Provides an independent critique of code. By using a different model family (e.g., GPT) than the main agent (e.g., Claude Sonnet), it achieves "near-Opus" performance at a lower cost through cross-model validation.
• Multi-Agentic Fleet (/fleet): The main agent breaks down complex tasks into sub-problems, dispatches sub-agents to solve them in parallel, and manages the overall workflow. This utilizes Copilot Memory to maintain a persistent record of repository details across all contributors and agents.

4. Notable Quotes

• "The conversation now shifts from you building with AI to actually building AI using the CLI." — Julia, regarding the power of the GitHub Copilot SDK.
• "We sort of marry the two [model families] and get the best of both worlds... you get a performance that is close to what you would get by using the Opus models." — On the efficacy of the Rubber Duck agent.

5. Synthesis

GitHub Copilot CLI transforms the terminal from a secondary context into a primary development environment. By offering three distinct modes—headless for automation, interactive for development, and server for application integration—it provides a flexible framework for modern software engineering. The shift toward multi-agentic, hierarchical workflows and cross-model validation represents a significant leap in developer productivity, allowing for complex, autonomous task completion while maintaining high standards of code quality and security.