Evaluate GitHub Copilot app and agentic workflow fit for EventRelay

[groupthinking]

Agent login

Agent[bot]

Agent run ID

Agent1

Objective

https://docs.github.com/en/copilot/how-tos/github-copilot-app/agent-sessions

https://docs.github.com/en/copilot/how-tos/github-copilot-app/managing-issues-and-pull-requests

https://docs.github.com/en/copilot/how-tos/github-copilot-app/using-scheduled-workflows

About the GitHub Copilot app

The GitHub Copilot app is a desktop application for agent-driven development that brings parallel workstreams, GitHub integration, and PR lifecycle management into one place.

Introduction

The GitHub Copilot app is a desktop application purpose-built for agent-driven development. It gives you a single place to direct AI agents across parallel workstreams, work with GitHub issues and pull requests, and manage the full development lifecycle—without context-switching between terminals, IDEs, and browser tabs.

The app is built on GitHub Copilot CLI and integrates natively with GitHub, so your repositories, branches, and CI pipelines work out of the box. It's designed for workflows where you want to run multiple agents in parallel and stay focused on directing work rather than doing it all yourself.

Availability

GitHub Copilot app is available for all Copilot plans. Copilot Business and Copilot Enterprise users must have the Copilot CLI policy enabled by an administrator.

Supported operating systems

The GitHub Copilot app supports the following operating systems:

• macOS
• Linux
• Windows

Benefits of using the GitHub Copilot app

• Work in parallel. Run multiple agent sessions at the same time, each on its own branch, so you can make progress on several tasks without waiting for one to finish.
• Stay in one place. Triage issues, direct agents, review changes, and land pull requests without switching between your terminal, IDE, and browser.
• Start fast. The app connects to GitHub natively—your repositories, branches, issues and pull requests work out of the box with no additional setup.
• Stay in control. Choose how much autonomy to give agents, from fully collaborative to fully autonomous, and adjust the model and reasoning effort for each session.
• Collaborate on a shared surface. Use canvases to create custom interfaces where people and agents can collaborate.

What can I do with the GitHub Copilot app?

• Parallel workspaces: Run multiple isolated agent sessions simultaneously, each with a dedicated git worktree and branch. You can also run sessions in cloud sandboxes (public preview) hosted by GitHub. For more information, see About cloud and local sandboxes for GitHub Copilot.
• Session modes: Choose how you work with agents: Interactive (collaborative), Plan (agent plans, you approve), or Autopilot (fully autonomous). You can also select from multiple LLMs and adjust reasoning effort for each session.
• Model selection: Select from multiple LLMs, including models from your own provider using bring your own key (BYOK), and adjust reasoning effort for each session.
• GitHub integration: Browse and find issues, start sessions from them, create and close pull requests, review pull requests, view CI check results, and search across your repositories—all within the app.
• Customizations: Configure and use global instructions, MCP servers, and agent skills.
• Automations: Save recurring agent tasks and run them on a schedule or on demand.
• Quick chats: Brainstorm in a conversation mode without creating a dedicated branch or workspace.
• Session history: Use /chronicle to get insights from previous sessions, including work you started in the app.
• Canvases: Open custom, agent-driven artifacts and interfaces where people and agents can collaborate.

GitHub Copilot app workflow

A typical workflow in the GitHub Copilot app looks like this:

1. Browse issues in a repository and pick one up, or start from a blank workspace.
2. Choose a session mode—Interactive, Plan, or Autopilot—and select a model.
3. Describe the task and let the agent create a branch, write code, and run tests.
4. Review the agent's changes, provide feedback, and iterate.
5. Create a pull request, leave a review, check whether CI passed, and merge the PR—all from within the app.

You can run several of these workflows in parallel, each in its own workspace, and switch between them as needed.

Optimizing AI usage in the GitHub Copilot app

Follow these practices to use AI credits more efficiently in the app:

• Match model capability to task complexity. Use lighter models for straightforward changes and higher-capability models for complex debugging, design decisions, and multi-step tasks.
• Choose the right session mode for the stage of work. Use Plan mode to validate scope and approach, use Interactive mode when you want tighter steering, and move to Autopilot when the task is well-defined.
• Use quick chats to scope before opening a full session. For early exploration, use Quick chats to clarify requirements and reduce rework before creating a dedicated session.
• Start a new session when you switch tasks. A new session keeps context focused and avoids carrying irrelevant history into unrelated work.
• Use usage insights regularly. Run /chronicle cost tips to find expensive patterns in your session usage and improve efficiency over time.

For more detailed optimization tips, see Optimizing your AI usage to maximize efficiency and reduce cost.

Providing feedback

To share feedback, click the Give feedback icon in the bottom-left corner of the app.

Public code

GitHub Copilot app may generate code that is a match or near match of publicly available code, even if the "Suggestions matching public code" policy is set to "Block." See Managing GitHub Copilot policies as an individual subscriber.

Further reading

• Getting started with the GitHub Copilot app

Acceptance criteria

No demo mock data allow. No hard coded input that generates false positives alike.

Every single file in the code base must be tested as a paid user.
By default assume nothing works until you have first hand material fact to prove otherwise.
All outputs must be measured and proven real after outputs finish and printed.
Always answer with specific clear action items and make no false claims to appear otherwis

Declared file scope

All branches

Allowed extra files

GitHub Copilot features

GitHub Copilot offers a suite of features for users and administrators.

Assistive features

These tools are used synchronously, providing advice or suggestions as people work on a task.

Copilot Chat

A chat interface that lets you ask coding-related questions. GitHub Copilot Chat is available on the GitHub website, in GitHub Mobile, in supported IDEs, and in Windows Terminal. Users can also use skills with Copilot Chat. See Asking GitHub Copilot questions in GitHub and Asking GitHub Copilot questions in your IDE.

Inline suggestions

Autocomplete-style suggestions from Copilot in supported IDEs. See Getting code suggestions in your IDE with GitHub Copilot.

If you use VS Code, Xcode, or Eclipse, you can also use next edit suggestions, which will predict the location of the next edit you are likely to make and suggest a completion for it.

Copilot pull request summaries

AI-generated summaries of the changes that were made in a pull request, which files they impact, and what a reviewer should focus on when they conduct their review. See Creating a pull request summary with GitHub Copilot.

Copilot in GitHub Desktop

Automatically generate commit messages and descriptions with Copilot in GitHub Desktop based on the changes you make to your project.

Agentic features

These features can work autonomously without direct human supervision. However, they typically need human approval to perform sensitive actions, such as running commands in a developer's terminal or merging a pull request.

Copilot CLI

A command line interface that lets you use Copilot in your terminal. Use the CLI to add features or fix bugs, then create a pull request. Start Copilot working on a task in your terminal, then continue working in the same session on GitHub.com, or on your mobile. See About GitHub Copilot CLI.

Copilot cloud agent

An autonomous AI agent that can research a repository, create an implementation plan, and make code changes on a branch. You can review the diff, iterate, and create a pull request when you're ready. You can also assign a GitHub issue to Copilot or ask it to open a pull request directly to complete a task. See GitHub Copilot cloud agent.

Third-party coding agents (public preview)

You can use third-party coding agents alongside Copilot cloud agent. Third-party agents are subject to the same security protections, mitigations, and limitations as Copilot cloud agent. See About third-party coding agents.

Copilot code review

AI-generated code review suggestions to help you write better code. See Using GitHub Copilot code review.

Several tools in Copilot code review are in public preview and subject to change. See About GitHub Copilot code review.

Agent mode in IDEs

Allow Copilot to work autonomously in the IDE. Copilot will determine which files to make changes to, offer code changes and terminal commands for the user's approval, and iterate to remediate issues until the original task is complete.

GitHub Spark (public preview)

Build and deploy full-stack applications using natural-language prompts that seamlessly integrate with the GitHub platform for advanced development. See Building and deploying AI-powered apps with GitHub Spark.

Features for customization

These features can be used to add context to Copilot and improve its performance. For a comparison of when to use each feature, see Copilot customization cheat sheet.

Copilot Spaces

Organize and centralize relevant content—like code, docs, specs, and more—into Spaces that ground Copilot’s responses in the right context for a specific task. See About GitHub Copilot Spaces.

Custom instructions

Enhance responses by providing contextual details on your preferences, tools, and requirements. See About customizing GitHub Copilot responses.

Copilot Memory (public preview)

Copilot can deduce and store useful information about a repository, which Copilot cloud agent and Copilot code review can use to improve the quality of their output when working in that repository. For more information, see About GitHub Copilot Memory.

Prompt files

Build and share reusable prompt instructions with additional context. A prompt file is a Markdown file, stored in your workspace, that mimics the existing format of writing prompts. See About customizing GitHub Copilot responses.

MCP servers

You can configure Model Context Protocol (MCP) servers for many Copilot features, giving Copilot access to external tools or data sources. See About Model Context Protocol (MCP).

Agent skills

Create folders of instructions, scripts, and resources that Copilot can load when relevant to improve its performance in specialized tasks. See About agent skills.

Custom agents

Create specialized versions of Copilot cloud agent with access to specific tools, instructions, and MCP servers. See About custom agents.

Features for administrators

The following features are available to organization and enterprise owners with a Copilot Business or Copilot Enterprise plan.

Policy management

Manage policies for Copilot in your organization or enterprise. See Managing policies and features for GitHub Copilot in your organization and Managing policies and features for GitHub Copilot in your enterprise.

Access management

Enterprise owners can specify which organizations in the enterprise can use Copilot, and organization owners can specify which organization members can use Copilot. See Managing access to GitHub Copilot in your organization and Managing access to Copilot in your enterprise.

Usage data

Review Copilot usage data within your organization or enterprise to inform how to manage access and drive adoption of Copilot. See Reviewing user activity data for GitHub Copilot in your organization and Viewing Copilot license usage in your enterprise.

Audit logs

Review audit logs for Copilot in your enterprise to understand what actions have been taken and by which users. See Reviewing audit logs for GitHub Copilot.

File exclusions

Configure Copilot to ignore certain files. This can be useful if you have files that you don't want to be available to Copilot. See Excluding content from GitHub Copilot.

Next steps

• To learn more about the plans available for GitHub Copilot, see Plans for GitHub Copilot.
• To start using Copilot, see [Setting up GitHub Copilot](/en/copilot/how-tos/set

Focused test paths

About agent skills

Skills allow Copilot to perform specialized tasks.

Note

Agent skills work with Copilot cloud agent, Copilot code review, the GitHub Copilot CLI, the GitHub Copilot app, and agent mode in Visual Studio Code and JetBrains IDEs.

About agent skills

Agent skills are folders of instructions, scripts, and resources that Copilot can load when relevant to improve its performance in specialized tasks. The Agent Skills specification is an open standard, used by a range of different AI systems.

You can create your own skills to teach Copilot to perform tasks in a specific, repeatable way—or use skills shared online, for example in the anthropics/skills repository or GitHub's community-created github/awesome-copilot collection.

You can also use gh skill in GitHub CLI to discover and install skills from GitHub repositories. For more information, see Adding agent skills for GitHub Copilot.

Copilot supports:

• Project skills, stored in your repository (.github/skills, .claude/skills, or .agents/skills)
• Personal skills, stored in your home directory and shared across projects (~/.copilot/skills or ~/.agents/skills)

Next steps

To create or add agent skills, see:

• Adding agent skills for GitHub Copilot
• Adding agent skills for GitHub Copilot CLI
• Customizing the GitHub Copilot app
• Copilot customization cheat sheet

About Model Context Protocol (MCP)

Model Context Protocol (MCP) is a protocol that allows you to extend the capabilities of GitHub Copilot by integrating it with other systems.

Overview of Model Context Protocol (MCP)

The Model Context Protocol (MCP) is an open standard that defines how applications share context with large language models (LLMs). MCP provides a standardized way to connect AI models to different data sources and tools, enabling them to work together more effectively.

You can use MCP to extend the capabilities of GitHub Copilot by integrating it with a wide range of existing tools and services. MCP works across all major Copilot surfaces—whether you're working in an IDE, using GitHub Copilot CLI, working in the GitHub Copilot app, or delegating tasks to an agent on GitHub.com. You can also use MCP to create new tools and services that work with Copilot, allowing you to customize and enhance your experience.

For more information on MCP, see the official MCP documentation. For a curated list of MCP servers from partners and the community, see the GitHub MCP Registry.

To learn how to configure and use MCP servers, see:

• Extending GitHub Copilot Chat with Model Context Protocol (MCP) servers for Copilot Chat in your IDE
• Adding MCP servers for GitHub Copilot CLI for Copilot CLI
• Configure MCP servers for your repository for repository MCP configuration on GitHub.com
• Customizing the GitHub Copilot app for information on MCP server support in the GitHub Copilot app
  Enterprises and organizations can choose to enable or disable use of MCP for members of their organization or enterprise with the MCP servers in Copilot policy. The policy is disabled by default. See Managing policies and features for GitHub Copilot in your enterprise and Managing policies and features for GitHub Copilot in your organization. The MCP policy only applies to users who have a Copilot Business or Copilot Enterprise subscription from an organization or enterprise that configures the policy. Copilot Free, Copilot Pro, Copilot Pro+, or Copilot Max do not have their MCP access governed by this policy.

Availability

MCP is supported across the following clients:

• IDEs: There is broad support for local MCP servers in clients such as Visual Studio Code, JetBrains IDEs, Xcode, and others. Support for remote MCP servers is growing, with editors like Visual Studio Code, Visual Studio, JetBrains IDEs, Xcode, Eclipse, Cursor, and Windsurf providing this functionality with OAuth or PAT. To find out if your preferred editor supports remote MCP servers, check the documentation for your specific editor.
• Copilot CLI: GitHub Copilot CLI supports both local and remote MCP servers. The GitHub MCP server is built in and available without additional configuration.
• GitHub Copilot app: The GitHub Copilot app supports MCP servers configured in your repository or Copilot CLI and lets you add additional MCP servers in app settings.
• Copilot cloud agent and Copilot code review: GitHub.com supports MCP servers configured at the repository level. The configuration applies to both Copilot cloud agent and Copilot code review. The GitHub MCP server and Playwright MCP server are configured by default.

About the GitHub MCP server

The GitHub MCP server is a Model Context Protocol (MCP) server provided and maintained by GitHub.

GitHub MCP server can be used to:

• Automate and streamline code-related tasks.
• Connect third-party tools (like Cursor, Windsurf, or future integrations) to leverage GitHub’s context and AI capabilities.
• Enable cloud-based workflows that work from any device, without local setup.
• Invoke GitHub tools, such as Copilot cloud agent (requires GitHub Copilot subscription) and code scanning (requires GitHub Advanced Security subscription), to assist with code generation and security analysis.

To learn how to set up and use the GitHub MCP server, see Using the GitHub MCP Server in your IDE.

To find out whether your editor supports the GitHub MCP server, and which connection and authentication methods are available, see Support by host application in the github/github-mcp-server repository.

Remote access

You can access the GitHub MCP server remotely through Copilot Chat in Visual Studio Code without any local setup. The remote server has access to additional toolsets only available in the remote GitHub MCP server. For a list of such tools, see Additional toolsets in the github/github-mcp-server repository.

The GitHub MCP server can also run locally in any MCP-compatible editor, if necessary.

Toolset customization

Important

Always review the GitHub MCP server repository at github/github-mcp-server for the latest toolsets and authoritative configuration guidance.

The GitHub MCP server supports enabling or disabling specific groups of functionalities via toolsets. Toolsets allow you to control which GitHub API capabilities are available to your AI tools.

Enabling only the toolsets you need improves your AI assistant's performance and security. Fewer tools means better tool selection accuracy and fewer errors. Disabling unused toolsets also frees up tokens in the AI's context window.

Toolsets do not only include tools, but also relevant MCP resources and prompts where applicable.

To learn how to configure toolsets for the GitHub MCP server, see Configuring toolsets for the GitHub MCP Server.

Security

For all public repositories, and private repositories covered by GitHub Advanced Security, interactions with the GitHub MCP server are secured by push protection, which blocks secrets in AI-generated responses and prevents them from being included in actions taken on your behalf. You can also proactively scan your code for exposed secrets from within your AI coding agent. For more information, see Scanning for secrets with the GitHub MCP server.

About the GitHub MCP Registry

The GitHub MCP Registry is a curated list of MCP servers from partners and the community. You can use the registry to discover new MCP servers and find ones that meet your specific needs. See the GitHub MCP Registry.

Note

The GitHub MCP Registry is currently in public preview and subject to change.

Agent finder

Agent finder is a discovery service that helps GitHub Copilot find the right capabilities—such as MCP servers, tools, agents, and skills—for a task at runtime, instead of requiring every capability to be configured in advance. Like an MCP registry, it searches a catalog of capabilities and returns ranked matches that GitHub Copilot can use on demand. Agent finder implements the open Agentic Resource Discovery (ARD) specification.

To use agent finder, download the agent finder skill and add it to your ~/.copilot/skills directory. For more information about agent skills, see About agent skills. To browse the catalog, see GitHub Agent Finder.

Next steps

• Extending GitHub Copilot Chat with Model Context Protocol (MCP) servers—Add MCP servers to Copilot Chat in your IDE
• Configure MCP servers for your repository—Configure repository MCP servers for Copilot cloud agent and Copilot code review
• Setting up the GitHub MCP Server—Set up the GitHub MCP server
• Using the GitHub MCP Server in your IDE—Use the GitHub MCP server
• Enhancing GitHub Copilot agent mode with MCP
• Copilot customization cheat sheet

• Your first agentic workflow

Get your first AI-powered automation running using a pre-built workflow and the GitHub CLI.

Note

GitHub Agentic Workflows are in public preview and subject to change.

Introduction

GitHub Agentic Workflows let you automate repository tasks using AI-powered workflows. For an overview of GitHub Agentic Workflows, see About GitHub Agentic Workflows.

In this guide, you'll add a pre-built agentic workflow—a daily repository status report—to an existing repository. This takes about 10 minutes and gives you a working example of automated agents running in GitHub Actions.

This quickstart focuses on getting your first workflow running. For deeper setup and troubleshooting guidance, see the GitHub Agentic Workflows documentation site.

Prerequisites

Before you begin, make sure you have:

• An AI account: GitHub Copilot, Anthropic Claude, OpenAI Codex, or Google Gemini

• A GitHub repository where you have write access

• GitHub Actions enabled for the repository

• GitHub CLI (gh) v2.0.0 or later installed and authenticated

  To check your version, run gh --version. To authenticate, run:

  gh auth login --scopes repo,workflow

You can complete this quickstart with any supported engine. GitHub Copilot is the default engine, and a GitHub Copilot plan is only required when you choose it.

Supported operating systems are Linux, macOS, and Windows with WSL.

Step 1: Install the gh aw extension

Install the GitHub Agentic Workflows extension for the GitHub CLI:

gh extension install github/gh-aw

Step 2: Add a workflow and trigger a run

From your repository root, run:

gh aw add-wizard githubnext/agentics/daily-repo-status

The add-wizard command accepts workflow references in OWNER/REPO/WORKFLOW-NAME format. This interactive process will:

1. Check repository prerequisites.
2. Prompt you to select an AI engine (Copilot is the default, or choose from other engines).
3. Guide you through secret and authentication setup for your chosen engine. Depending on the engine you choose, the wizard may prompt you to configure COPILOT_GITHUB_TOKEN, ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY. See the authentication reference article for setup instructions.
4. Generate the workflow markdown file and compile the corresponding .lock.yml file.
5. Open a pull request that adds both generated files in .github/workflows/.
6. Let you review and merge the pull request yourself, or choose a flow that merges it for you.

Once the workflow is created, you will be asked if you want to run it immediately. Select Yes to trigger the workflow.

Step 3: Wait for the workflow to complete

An automated workflow run typically takes 2-3 minutes. Once complete, a new issue appears in your repository with a daily status report that analyzes:

• Recent repository activity (issues, pull requests, discussions, releases)
• Progress tracking and highlights
• Actionable next steps for maintainers

Step 4: Customize the workflow (optional)

You can edit the workflow to match your priorities:

1. Open .github/workflows/daily-repo-status.md in your repository.

2. Edit the markdown body to describe what you want the report to cover—your issue backlog, CI setup, testing, performance, or roadmap.

3. If you changed the frontmatter configuration, recompile the workflow:

   gh aw compile

4. Commit and push your changes.

5. Optionally trigger another run:

   gh aw run daily-repo-status

Next steps

• To create your own custom agentic workflows, see Creating GitHub Agentic Workflows.
• For advanced patterns and the full reference, see the GitHub Agentic Workflows documentation site.

agent-ai-automation.yml
Key Benefits of the Dogfooding Loop for AI Agent Development.md

Pre-dispatch confirmation

• Objective, acceptance criteria, scope, and focused-test expectations are complete before delegation.

[linear-code]

GRV-114

[github-actions]

👋 Thanks for opening this issue! It has been automatically labeled for triage.

[github-actions]

Agent task intent frozen for completion-gate evaluation.