`--allow-all`, and its alias `--yolo`, are permissions-related options that you can pass to the `copilot` command when you start an interactive session. For a full list of available options, see [AUTOTITLE](/copilot/reference/copilot-cli-reference/cli-command-reference#command-line-options).

* **The research agent uses a specific model**: The research agent is hard-coded to use a particular AI model (see [AUTOTITLE](/copilot/reference/copilot-cli-reference/cli-command-reference#built-in-agents)). The model selection is not configurable via the `/model` command. The research agent always uses the defined model regardless of what model you've selected for your main session.

title: Automating tasks with Copilot CLI and GitHub Actions

shortTitle: Automate with Actions

intro: Integrate {% data variables.copilot.copilot_cli %} into your {% data variables.product.prodname_actions %} workflows.

product: '{% data reusables.gated-features.copilot-cli %}'

versions:

feature: copilot

contentType: how-tos

category:

- Build with Copilot CLI

- Author and optimize with Copilot

redirect_from:

- /copilot/how-tos/copilot-cli/automate-with-actions

You can run {% data variables.copilot.copilot_cli %} in a {% data variables.product.prodname_actions %} workflow to automate AI-powered tasks as part of your CI/CD process. For example, you can summarize recent repository activity, generate reports, or scaffold project content. {% data variables.copilot.copilot_cli %} runs on the Actions runner like any other CLI tool, so you can install it during a job and invoke it from workflow steps.

You can define a job in a {% data variables.product.prodname_actions %} workflow that: installs {% data variables.copilot.copilot_cli_short %} on the runner, authenticates it, runs it in programmatic mode, and then handles the results. Programmatic mode is designed for scripts and automation and lets you pass a prompt non-interactively.

Workflows can follow this pattern:

1. **Trigger**: Start the workflow on a schedule, in response to repository events, or manually.

1. **Setup**: Checkout code, set up environment.

1. **Install**: Install {% data variables.copilot.copilot_cli %} on the runner.

1. **Authenticate**: Ensure the CLI has the necessary permissions to access the repository and make changes.

1. **Run {% data variables.copilot.copilot_cli_short %}**: Invoke {% data variables.copilot.copilot_cli_short %} with a prompt describing the task you want to automate.

The following workflow generates details of changes made today in the default branch of the repository and displays these details as the summary for the workflow run.

```yaml copy

name: Daily summary

on:

workflow_dispatch:

# Run this workflow daily at 5:30pm UTC

schedule:

- cron: '30 17 * * *'

permissions:

contents: read

jobs:

daily-summary:

runs-on: ubuntu-latest

steps:

- name: Checkout

uses: {% data reusables.actions.action-checkout %}

with:

fetch-depth: 0

- name: Set up Node.js environment

uses: {% data reusables.actions.action-setup-node %}

- name: Install Copilot CLI

run: npm install -g @github/copilot

- name: Run Copilot CLI

env:

{% raw %}COPILOT_GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}{% endraw %}

run: |

The `permissions` block defines the scope granted to the built-in `GITHUB_TOKEN`. Because this workflow reads repository data and prints a summary to the logs, it requires `contents: read`.

1. Go to your personal settings for creating a {% data variables.product.pat_v2 %}: [github.com/settings/personal-access-tokens/new](https://github.com/settings/personal-access-tokens/new?ref_product=copilot&ref_type=engagement&ref_style=text).

This example uses several options after the CLI prompt:

After you confirm the workflow generates a summary of changes, you can adapt the same pattern to other automation tasks. Start by changing the prompt you pass to `copilot -p PROMPT`, then decide what you want to do with the output. For example, you could:

title: Automate with GitHub Copilot CLI

shortTitle: Automate with Copilot CLI

intro: 'Learn how to use {% data variables.copilot.copilot_cli_short %} in the terminal, in scripts, or in Actions workflows.'

versions:

feature: copilot

contentType: how-tos

children:

- /quickstart

- /run-cli-programmatically

- /automate-with-actions

title: Quickstart for automating with {% data variables.copilot.copilot_cli %}

shortTitle: Quickstart

allowTitleToDifferFromFilename: true

intro: "Build an automation with {% data variables.copilot.copilot_cli_short %} in minutes."

versions:

feature: copilot

redirect_from:

- /copilot/how-tos/copilot-cli/automate-copilot-cli/overview

contentType: how-tos

category:

- Author and optimize with Copilot # Copilot discovery page

- Build with Copilot CLI # Copilot CLI bespoke page

- Quickstarts

You can use {% data variables.copilot.copilot_cli %} to programmatically run Copilot prompts. There are two main ways to do this:

* Run a {% data variables.copilot.copilot_cli_short %} prompt directly from your terminal.

* Write a script or automation that leverages {% data variables.copilot.copilot_cli_short %}.

This guide will walk you through a simple use case for each option.

When you want to pass {% data variables.copilot.copilot_cli_short %} a prompt without initiating an interactive session, use the `-p` flag.

```shell copy

copilot -p "Summarize what this file does: ./README.md"

Any prompt you would type in an interactive session works with `-p`.

The real power of programmatic mode comes from writing scripts to automate AI-powered tasks. Within a script, you can generate the prompt, or replace parts of a prompt with dynamic content, and then capture the output or pass it to another part of the script.

Let's create a script that finds all files larger than 10 MB in the current directory, uses {% data variables.copilot.copilot_cli_short %} to generate a brief description of each file, and then emails a summary report.

1. In your repository, create a new file called `find_large_files.sh` and add the following content.

```bash copy

#!/bin/bash

# Find files over 10 MB, use Copilot CLI to describe them, and email a summary

EMAIL_TO="[email protected]"

SUBJECT="Large file found"

BODY=""

while IFS= read -r -d '' file; do

size=$(du -h "$file" | cut -f1)

description=$(copilot -p "Describe this file briefly: $file" -s 2>/dev/null)

BODY+="File: $file"$'\n'"Size: $size"$'\n'"Description: $description"$'\n\n'

done < <(find . -type f -size +10M -print0)

if [ -z "$BODY" ]; then

echo "No files over 10MB found."

exit 0

fi

echo -e "To: $EMAIL_TO\nSubject: $SUBJECT\n\n$BODY" | sendmail "$EMAIL_TO"

echo "Email sent to $EMAIL_TO with large file details."

```

1. Make the script executable.

```shell copy

1. Run the script.

```shell copy

This script leverages {% data variables.copilot.copilot_cli_short %} to generate descriptions of the files you are searching for, so you can quickly understand the contents of large files without opening them.

You can also automatically trigger these scripts in response to events, such as a new file being added to a directory, or on a schedule using cron jobs or CI/CD pipelines.

* [AUTOTITLE](/copilot/how-tos/copilot-cli/automate-copilot-cli/run-cli-programmatically)

* [AUTOTITLE](/copilot/how-tos/copilot-cli/automate-copilot-cli/automate-with-actions)

* [AUTOTITLE](/copilot/reference/copilot-cli-reference/cli-programmatic-reference)