GitHub Copilot Agents

This lesson explains GitHub Copilot “agents” — the @-mention scoped assistants inside Copilot Chat — and shows how to control context in your prompts. You’ll learn how to invoke agents, which contexts they can access, and see practical examples (including a small Pygame demo and a Flask scaffold) that illustrate typical agent workflows. What are Copilot agents?

Agents are addressable by @ mentions in the Copilot chat (similar to tagging a person).
Each agent is configured with specialized knowledge and access to specific contexts (for example: workspace files, open editor, or terminal output).
When invoked, an agent inspects the contexts it can access and uses natural language processing to produce contextually appropriate responses.

How to invoke an agent

Type @ in the Copilot chat prompt.
Select the agent by name (for example, @workspace).
Frame your question for the agent’s domain to get the best results (e.g., ask @terminal shell- or environment-specific questions, and @vscode questions about Visual Studio Code settings).
Agents limit their reasoning to the contexts they can access, so tailored prompts lead to more useful answers.

Agents can access the data sources you permit (workspace files, open editor, terminal). Do not share secrets or sensitive data in prompts and review agent-suggested edits before applying them.

Common mention examples

@github
@remote-ssh
@terminal
@vscode
@workspace
@terminal /explain
@vscode /search
@vscode /startDebugging
@workspace /explain
@workspace /fix
@workspace /fixTestFailure
@workspace /new
<> index.html Current file

A dark presentation slide titled "Usage" with a highlighted "Accessing and Invoking Agents" banner. Below are three blue rounded boxes explaining: type "@" to see available agents, select one by typing its "@name", and then frame your question for that agent.

Common agents and scopes

@workspace — understands project structure, dependencies, and code relationships.
@terminal — helps with command-line operations, shell commands, and terminal tools.
@vscode — specializes in Visual Studio Code features and settings.
@azure — preview agent for Azure services, deployments, and configs.
@github — GitHub-specific Copilot skills and platform integrations.

A slide titled "Common Agents and Their Purposes" shows five agent cards: @workspace, @terminal, @vscode, @azure, and @github. Each card gives a short role summary (project structure/dependencies, terminal commands, VS Code features, Azure deployments/config, and GitHub Copilot integrations).

Agents in action — walkthroughs and code Below are consolidated, corrected examples pulled from a demo project (a minimal Pygame simulation of a 4-way traffic intersection) and typical workflows you might use with Copilot agents. These examples are arranged so workspace/terminal/vscode agents can reference the same small set of functions and constants.

Pygame simulation — relevant portions

This concise excerpt contains the constants and functions referenced by the agents. Use it as a minimal context sample so agents can reason about your project.

#!/usr/bin/env python3
"""
A standalone Pygame simulation of a 4-way traffic intersection.
Cars spawn from each direction and travel straight. They obey a coordinated
traffic light cycle (green -> yellow -> red) and stop before entering the
intersection when needed.
"""

import pygame
import sys
import random

# ----------------------------- Configuration Constants -----------------------------
WINDOW_WIDTH, WINDOW_HEIGHT = 800, 800
ROAD_WIDTH = 100
CENTER_X, CENTER_Y = WINDOW_WIDTH // 2, WINDOW_HEIGHT // 2

# Example stop line positions relative to center
STOP_LINE = {
    'north': CENTER_Y - ROAD_WIDTH // 2,
    'south': CENTER_Y + ROAD_WIDTH // 2,
    'east': CENTER_X + ROAD_WIDTH // 2,
    'west': CENTER_X - ROAD_WIDTH // 2,
}

LIGHT_OFFSET = 40
LIGHT_RADIUS = 10
LIGHT_COLORS = {
    'green': (0, 255, 0),
    'yellow': (255, 255, 0),
    'red': (255, 0, 0),
}

Traffic light drawing helper

def draw_traffic_light(surface, direction, state):
    """
    Draws a circular traffic light for a given direction at a fixed offset
    from the intersection.
    """
    if direction == 'north':
        pos = (CENTER_X, STOP_LINE['north'] - LIGHT_OFFSET)
    elif direction == 'south':
        pos = (CENTER_X, STOP_LINE['south'] + LIGHT_OFFSET)
    elif direction == 'east':
        pos = (STOP_LINE['east'] - LIGHT_OFFSET, CENTER_Y)
    elif direction == 'west':
        pos = (STOP_LINE['west'] + LIGHT_OFFSET, CENTER_Y)
    else:
        # default to center if an unknown direction is passed
        pos = (CENTER_X, CENTER_Y)

    color = LIGHT_COLORS.get(state, (128, 128, 128))
    pygame.draw.circle(surface, color, pos, LIGHT_RADIUS)

Example deterministic light-state function

def get_light_state(direction, cycle_timer):
    """
    Example: determine light state based on a cycle timer.
    This is a placeholder; replace with your actual cycle logic.
    """
    cycle_phase = cycle_timer % 10
    if cycle_phase < 6:
        return 'green'
    elif cycle_phase < 8:
        return 'yellow'
    else:
        return 'red'

Minimal main loop skeleton

def main():
    pygame.init()
    screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
    clock = pygame.time.Clock()
    cycle_timer = 0

    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        # update state
        cycle_timer += 1

        # draw frame (placeholder)
        screen.fill((30, 30, 30))
        draw_traffic_light(screen, 'north', get_light_state('north', cycle_timer))
        pygame.display.flip()
        clock.tick(30)

    pygame.quit()
    sys.exit()


if __name__ == "__main__":
    main()

VS Code Copilot Chat experimental setting

If you want Copilot Chat to open in a dedicated chat view in VS Code, this example setting places the “Ask Chat” command into the chat view:

{
  "workbench.commandPalette.experimental.askChatLocation": "chatView"
}

Terminal and virtual environment workflow

Typical terminal commands an agent might suggest for setting up a Python virtual environment and installing Pygame:

python3 -m venv testenv
source testenv/bin/activate
pip install --upgrade pip
pip install pygame
python main.py

When launching a Pygame program, you may see a startup message like:

pygame 2.x.x (SDL 2.x.x, Python 3.x.x)
Hello from the pygame community. https://www.pygame.org/contribute.html

Agent mode (experimental) — example Flask flow

Some Copilot experiences include an “agent mode” that can autonomously propose multiple edits, create files, or run terminal commands. Below is a minimal Flask app an agent might scaffold:

from flask import Flask, jsonify, request

app = Flask(__name__)

# in-memory "database"
users = []

@app.route('/', methods=['GET'])
def hello_world():
    return 'Hello, World!'

@app.route('/users', methods=['POST'])
def create_user():
    data = request.get_json() or {}
    user = {
        "id": len(users) + 1,
        "name": data.get("name"),
        "email": data.get("email"),
    }
    users.append(user)
    return jsonify(user), 201

if __name__ == '__main__':
    app.run(debug=True)

Commands an agent might run to scaffold and run the Flask app:

python3 -m venv venv
source venv/bin/activate
pip install Flask
python app.py

Typical Flask dev-server output:

 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [DD/Mon/YYYY HH:MM:SS] "GET / HTTP/1.1" 200 -

Agent mode is currently experimental in some VS Code previews. It can perform file edits and run terminal commands on your behalf — review suggested changes before accepting them.

Notes on scope and exam relevance

GitHub Copilot scoped agents (@workspace, @terminal, @vscode, etc.) operate within defined contexts and are useful for targeted assistance related to those contexts.
“Agent mode” is a higher-level, more autonomous experience (can create files and run commands). It is typically separate from the per-domain agents and may be in preview; confirm whether it is covered in exam or course materials.
When preparing for assessments, focus on the behavior and limits of the per-domain agents unless the exam explicitly includes experimental agent mode capabilities.

Best practices for prompting agents

Mention the agent explicitly: start a prompt with @workspace or @terminal to route the question.
Provide minimal, relevant context in your prompt (file path, function name, error output).
Ask for step-by-step actions when requesting changes that affect multiple files or commands.
Review and test any code or terminal commands that an agent suggests before accepting them.

Summary table — common agent tasks

Agent	Primary scope	Example prompt
`@workspace`	Project files, dependencies, code relationships	`@workspace /explain main.py`
`@terminal`	Shell commands, environment setup, logs	`@terminal /explain pip install`
`@vscode`	Editor settings, debugging, extensions	`@vscode /startDebugging`
`@azure`	Azure services and deployments (preview)	`@azure /deploy`
`@github`	GitHub integrations, PRs, repo metadata	`@github /create-pr`

Links and references

GitHub Copilot documentation
Pygame
Flask
VS Code: Copilot Chat experimental feature documentation (check your VS Code preview channel notes)

That covers the core concepts, invocation patterns, and practical examples for using GitHub Copilot agents and the experimental agent-mode experience. Use the examples above as a template for agent-assisted development workflows and adapt prompts to the specific contexts your agents can access.

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

GitHub Copilot Agents

Watch Video