Split (1)

train · 3.34k rows

text stringlengths 12 91.7k	metadata dict
Often, it's helpful to group information in context to help people complete a complex task, understand a set of related tasks, or illustrate an entire workflow. Use longer articles combining content types to ensure people find contextual content in the right place. Longer articles also help eliminate duplication of con...	{ "source": "github-docs/contributing/style-guide-and-content-model/about-combining-multiple-content-types.md", "title": "About combining multiple content types" }
Our content model explains the purpose of each type of content we create within , and what to include when you write or update an article. We use a content model to ensure that our content consistently, clearly, and comprehensively communicates the information that people need to achieve their goals with . We use these...	{ "source": "github-docs/contributing/style-guide-and-content-model/about-the-content-model.md", "title": "About the content model" }
Conceptual content helps people understand a feature or topic by providing a clear, high-level overview, explanation of how the feature or topic can help them on their journey, and context like use cases or examples. We create concepts articles and conceptual sections within other articles. Most major products, feature...	{ "source": "github-docs/contributing/style-guide-and-content-model/concepts-content-type.md", "title": "Concepts content type" }
About the structure of an article Within an article, there is a standard order of content sections. Every article contains required elements. Articles will also contain conditional elements and optional elements outlined in content design or creation. See the guidelines below for more details. Titles Titles fully desc...	{ "source": "github-docs/contributing/style-guide-and-content-model/contents-of-a-github-docs-article.md", "title": "Contents of a GitHub Docs article" }
Get started content provides an entry point into using GitHub products and features. This section should contain only the minimum essential information a user needs before they move on to concepts and how-tos. We do this to be concise, and also so it doesn't seem complicated just to get started with a feature. Get sta...	{ "source": "github-docs/contributing/style-guide-and-content-model/get-started-content-type.md", "title": "Get started content type" }
How-tos contain numbered steps that describe how to use products to accomplish a task. Generally, they are necessary to get the most from using . How-to articles focus on the minimum essential steps for completing a task. They may link to other content types as prerequisites (especially concepts or reference) or next ...	{ "source": "github-docs/contributing/style-guide-and-content-model/how-to-content-type.md", "title": "How-to content type" }
Quickstarts enable people to quickly complete a discrete, focused task by illustrating a workflow with only essential steps, in about five minutes or 600 words. Quickstarts can be used for quickly getting set up with a new tool, or for quickly completing another task. For more complex tasks, use a tutorial. Quickstarts...	{ "source": "github-docs/contributing/style-guide-and-content-model/quickstart-content-type.md", "title": "Quickstart content type" }
Reference content is consulted for specific pieces of information. It’s information you can quickly check, meaning there’s less emphasis on sentences and paragraphs. Reference includes information that may be best represented in tables, lists, or other structured formats. We might think of reference as including our au...	{ "source": "github-docs/contributing/style-guide-and-content-model/reference-content-type.md", "title": "Reference content type" }
Good release notes provide administrators the necessary information to plan system upgrades in environments that require change control, and support end users who want to understand and prepare to use new features and functionality. Writers source, edit, and publish release notes in collaboration with product DRIs, fe...	{ "source": "github-docs/contributing/style-guide-and-content-model/release-note-content-type.md", "title": "Release note content type" }
<!-- A condensed version of this style guide is available at .github/instructions/style-guide-summary.instructions.md, optimized for AI agents and quick reference. If you make significant changes to this full guide, update the summary file as well. -- [!NOTE] These guidelines are specific to 's documentation. For gen...	{ "source": "github-docs/contributing/style-guide-and-content-model/style-guide.md", "title": "Style guide" }
Uses powers for good Yes No Yes No [^1]: Not to be confused with Davy Jones of The Monkees [^2]: Also humans \| \| Mona \| Ursula \| Paul \| Davy Jones[^1] \| \|---\|---\|---\|---\|---\| \|Favorite pastime\| Shipping code \| Tricking mermaids[^2] \| Predicting sports \| Haunting seafarers \| \|Uses powers for good\| Yes \| No \| Yes \| N...	{ "source": "github-docs/contributing/style-guide-and-content-model/style-guide.md", "title": "Style guide" }
MIT License Copyright YEAR COPYRIGHT-HOLDER Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distri...	{ "source": "github-docs/contributing/style-guide-and-content-model/style-guide.md", "title": "Style guide" }
TEXT ### Setting up for Windows The application is supported for all versions of Windows, but the set up steps differ. * [Windows 98](#windows-98) * [Windows Vista](#windows-vista) * [Windows 11](#windows-11) #### Windows 98 TEXT #### Windows Vista TEXT #### Windows 11 TEXT ### Setting up for Linux	{ "source": "github-docs/contributing/style-guide-and-content-model/style-guide.md", "title": "Style guide" }
TEXT Tables Tables are added to the using Markdown. Because tables can be challenging to read and maintain, make sure that the data in a table is best represented in a table and not another format, like a list, before creating a table. Every row in a table must begin and end with a pipe, . Use tables only for presen...	{ "source": "github-docs/contributing/style-guide-and-content-model/style-guide.md", "title": "Style guide" }
Use troubleshooting sections in guides or procedural articles to keep solutions close to procedures. Work with support and product managers to surface common errors and include them in the documentation. Known issues Known issues are a subset of troubleshooting content specifically designed to respond to bugs, UX/UI i...	{ "source": "github-docs/contributing/style-guide-and-content-model/troubleshooting-content-type.md", "title": "Troubleshooting content type" }
Tutorials help people learn about products and solve real world problems by guiding them through the entire workflow to complete a task. Tutorials are more conversational in tone than other content. A tutorial feels like a developer-to-developer conversation while remaining accessible to readers with varied technical k...	{ "source": "github-docs/contributing/style-guide-and-content-model/tutorial-content-type.md", "title": "Tutorial content type" }
About 's documentation fundamentals These fundamentals are required for documentation. Use the lists below to help ensure your contributions are accurate, accessible and inclusive, and consistent. Accurate Documentation is correct and accurate. Ensure that the content is free from factual errors. Ensure that the co...	{ "source": "github-docs/contributing/writing-for-github-docs/about-githubs-documentation-fundamentals.md", "title": "About GitHub's documentation fundamentals" }
About the documentation philosophy As the home to the world's largest community of developers, we want to make sure that our documentation is accurate, valuable, inclusive, and easy to use. Our documentation philosophy leads us toward these goals. We advocate for our users. This can occur at any point in the document...	{ "source": "github-docs/contributing/writing-for-github-docs/about-githubs-documentation-philosophy.md", "title": "About GitHub's documentation philosophy" }
About code annotations Code annotations help explain longer code examples by describing what a code example does and why. The annotations render next to the code example in a two pane layout, so we can write longer annotations without making the code itself difficult to read. We only annotate full code examples, not sn...	{ "source": "github-docs/contributing/writing-for-github-docs/annotating-code-examples.md", "title": "Annotating code examples" }
About documentation At , we strive to create documentation that is accurate, valuable, inclusive, accessible, and easy to use. Before contributing to , please take a moment to familiarize yourself with 's documentation philosophy, fundamentals, and content design principles: AUTOTITLE AUTOTITLE AUTOTITLE Best prac...	{ "source": "github-docs/contributing/writing-for-github-docs/best-practices-for-github-docs.md", "title": "Best practices for GitHub Docs" }
Changing the title of an article Sometimes, it's necessary to change the title of a help article. There are several considerations to keep in mind when you retitle an article. Background on changing the filename The title of the article corresponds directly to the name of the Markdown file that contains that article, ...	{ "source": "github-docs/contributing/writing-for-github-docs/changing-an-articles-title.md", "title": "Changing an article's title" }
About redirects If a change is made to an article that affects people's ability to find it, we create a redirect from any outdated versions to the current content. We might need to do this if an article's title is changed, a new version is added, or the location of the file is changed. Redirects can be configured local...	{ "source": "github-docs/contributing/writing-for-github-docs/configuring-redirects.md", "title": "Configuring redirects" }
About 's content design principles We create product documentation that helps, teaches, and engages everyone who uses . One step of this work is designing the content that we write. We follow these principles when designing and planning content. Our content is user-centered and inclusive. We respect everyone who visit...	{ "source": "github-docs/contributing/writing-for-github-docs/content-design-principles.md", "title": "Content design principles" }
About diagrams in Diagrams use shapes, lines, and labels to explain concepts visually. We use diagrams to support textual information in . Diagrams do not make information less complex, but they present a different way to receive and process information. Some people want to be shown information instead of reading it. ...	{ "source": "github-docs/contributing/writing-for-github-docs/creating-diagrams-for-github-docs.md", "title": "Creating diagrams for {% data variables.product.prodname_docs %}" }
About reusables Reusables are long strings of reusable text, such as paragraphs or procedural lists, that can be referenced in multiple content files. We use Markdown (instead of YAML) for reusables. Markdown makes it possible for our localization pipeline to split the strings into smaller translatable segments, leadin...	{ "source": "github-docs/contributing/writing-for-github-docs/creating-reusable-content.md", "title": "Creating reusable content" }
About screenshots in There are positives and negatives to adding a screenshot. Screenshots make articles more visually scannable and make instructions easier to understand, especially for people who have difficulty reading. When supplied with alt text, screenshots help blind and low-vision users collaborate with sight...	{ "source": "github-docs/contributing/writing-for-github-docs/creating-screenshots.md", "title": "Creating screenshots" }
Directory Usage --------- ------ /assets/images Images that are not specific to any product. /assets/images/enterprise/enterprise-server Images that are applicable to all releases of (GHES), or are applicable to the current release and future releases. /assets/images/enterprise/<release number, such as /assets/im...	{ "source": "github-docs/contributing/writing-for-github-docs/creating-screenshots.md", "title": "Creating screenshots" }
About tool switchers In some articles, we write content tailored to different tools (the UI, , , cURL, , , GraphQL API, etc.) The tool switcher lets people select a tool to see only the content that is relevant to that tool since tools may have different conceptual or procedural information. People can use the tool sw...	{ "source": "github-docs/contributing/writing-for-github-docs/creating-tool-switchers-in-articles.md", "title": "Creating tool switchers in articles" }
About search engine optimization (SEO) Search engine optimization (SEO) is the practice of earning visibility for web content in search engine results, such as those of Google and Bing. Google search is the top referrer to and the most common entry point for our users. We can plan and write our content to improve SEO....	{ "source": "github-docs/contributing/writing-for-github-docs/making-content-findable-in-search.md", "title": "Making content findable in search" }
Concepts article template Use the content model for full instructions and examples on how to write conceptual content. For more information, see AUTOTITLE. <!-- markdownlint-disable search-replace -- {% raw %}--- title: 'About <subject>' shortTitle: '<subject>' intro: 'Article intro. See tips for a great intro below.' ...	{ "source": "github-docs/contributing/writing-for-github-docs/templates.md", "title": "Templates" }
Build on the quick phrasing above by - Clarifying the audience - Clearly stating prerequisites and prior knowledge needed - Stating what the user will accomplish or build {% endcomment %} ## Step one: Action the user will take {% comment %} In one sentence, describe what the user will do in this step Steps should break...	{ "source": "github-docs/contributing/writing-for-github-docs/templates.md", "title": "Templates" }
Remember to show code snippets in context {% endcomment %} ## Further reading {% comment %} Include a bulleted list of tutorials or articles the user can reference to extend the concepts taught in this tutorial {% endcomment %} - [Article title](article-URL){% endraw %} <!-- markdownlint-enable search-replace -- Langu...	{ "source": "github-docs/contributing/writing-for-github-docs/templates.md", "title": "Templates" }
About using Markdown and Liquid in are written using Markdown, which is a human-friendly syntax for formatting plain text. We use the variant of Markdown called Flavored Markdown and ensure that it is compliant with CommonMark. For more information, see AUTOTITLE. We use Liquid syntax to expand the functionality to ...	{ "source": "github-docs/contributing/writing-for-github-docs/using-markdown-and-liquid-in-github-docs.md", "title": "Using Markdown and Liquid in GitHub Docs" }
Improve the variable names in this function There are many examples of prompt blocks with context in the Cookbook. For example, see AUTOTITLE. Inline prompts For most inline prompts, mark these by using backticks, just like inline code. If the prompt does not require any context, you can add a clickable icon after t...	{ "source": "github-docs/contributing/writing-for-github-docs/using-markdown-and-liquid-in-github-docs.md", "title": "Using Markdown and Liquid in GitHub Docs" }
About YAML frontmatter YAML frontmatter is an authoring convention popularized by Jekyll that provides a way to add metadata to pages. It is a block of key-value content that lives at the top of every Markdown file within . For more information, see the YAML frontmatter documentation. YAML frontmatter values The follo...	{ "source": "github-docs/contributing/writing-for-github-docs/using-yaml-frontmatter.md", "title": "Using YAML frontmatter" }
Article type Maximum character length --- --- articles 31 categories 27 map topics 30 Example: title: Contributing to projects with GitHub Desktop shortTitle: Contributing to projects intro Purpose: Sets the intro for the page. This string will render after the title. Type: String Optional....	{ "source": "github-docs/contributing/writing-for-github-docs/using-yaml-frontmatter.md", "title": "Using YAML frontmatter" }
On , we provide versions of our documentation that reflect the differences in UI and functionality across 's major product offerings. Contributors can use versioning syntax to scope content to a specific product offering. Versioning syntax allows the reader to manually choose the version of the documentation that appli...	{ "source": "github-docs/contributing/writing-for-github-docs/versioning-documentation.md", "title": "Versioning documentation" }
Operator Meaning Example ------ = Equal to Newer than < Older than != Not equal to (don't use not in ranges) The Liquid operators ==, =, and <= are not supported in the . Logical operators When all operands must be true for the condition to be true, use the operator and: {% raw %}{% ifversion ghes > 2.21 and ghe...	{ "source": "github-docs/contributing/writing-for-github-docs/versioning-documentation.md", "title": "Versioning documentation" }
About writing content that is translation-friendly Use the following guidelines to ensure the content you create can be successfully translated. For more information, see Style guide. Use examples that are generic and can be understood by most people. Avoid examples that are controversial or culturally specific to a ...	{ "source": "github-docs/contributing/writing-for-github-docs/writing-content-to-be-translated.md", "title": "Writing content to be translated" }
Introduction cloud and local sandboxes are the execution platform powering secure sandboxed experiences for , both locally and in the cloud. As takes more actions on your behalf—running tools, executing commands, and modifying files—sandboxing provides the isolation, portability, and policy controls needed to adopt a...	{ "source": "github-docs/copilot/concepts/about-cloud-and-local-sandboxes.md", "title": "About cloud and local sandboxes for {% data variables.product.prodname_copilot %}" }
How can my enterprise use only? To use , a user must authenticate to an account on that has a license for . You can assign a license to a user through a subscription if they're a member of an organization or enterprise that you administer. If you don't already manage users through an organization or enterprise, you ...	{ "source": "github-docs/copilot/concepts/about-enterprise-accounts-for-copilot-business.md", "title": "About enterprise accounts for Copilot Business" }
[!NOTE] Agent skills work with , , the , the , and agent mode in and . About agent skills Agent skills are folders of instructions, scripts, and resources that 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 ...	{ "source": "github-docs/copilot/concepts/agents/about-agent-skills.md", "title": "About agent skills" }
Enterprise-managed plugin standards allow administrators to define and enforce policies for plugin availability. By configuring a file, administrators can specify which plugin marketplaces are available to users and which plugins are installed automatically. Where plugin standards apply Plugin standards apply to all ...	{ "source": "github-docs/copilot/concepts/agents/about-enterprise-plugin-standards.md", "title": "About enterprise-managed plugin standards" }
About are AI-powered repository automations that you define in markdown and run as workflows. Unlike traditional automation with fixed if-then rules, use coding agents to understand context, make decisions, and take meaningful actions—all from natural language instructions. In practice, compared with traditional wo...	{ "source": "github-docs/copilot/concepts/agents/about-github-agentic-workflows.md", "title": "About GitHub Agentic Workflows" }
Plugins provide a way to distribute custom functionality. You can use a plugin to add a preconfigured set of capabilities to , including and . What is a plugin? A distributable package that extends 's functionality. A bundle of components in a single installable unit. What plugins contain A plugin can contain som...	{ "source": "github-docs/copilot/concepts/agents/about-plugins.md", "title": "About {% data variables.product.prodname_copilot %} plugins" }
[!NOTE] Third-party coding agents are currently in . Introduction You can use third-party coding agents alongside to work asynchronously on your development tasks. You can assign an existing issue or give a prompt to an agent, which will work on the required changes and create a pull request. When the agent finishes,...	{ "source": "github-docs/copilot/concepts/agents/about-third-party-coding-agents.md", "title": "About third-party coding agents" }
[!NOTE] Introduction are powered by . To learn more, see AUTOTITLE. For example, an could analyze your product analytics, scan your application for security vulnerabilities, or add feature flags to a pull request, then connect back to the partner's systems to complete the task. Where you can use You can use thes...	{ "source": "github-docs/copilot/concepts/agents/agent-apps.md", "title": "About agent apps" }
[!NOTE] The coding agent is currently in . Introduction The coding agent uses the Claude Agent SDK and can be powered by your existing subscription. For information about , see the documentation. coding agent Before you can assign tasks to coding agent, it must be enabled. See AUTOTITLE. To learn more about usi...	{ "source": "github-docs/copilot/concepts/agents/anthropic-claude.md", "title": "Anthropic Claude" }
[!NOTE] Rationale, confidence, and approvals for are in and subject to change. run an agent to triage issues for you, applying labels, setting types and fields, assigning issues, and closing them, without a person initiating each change. Rationale, confidence, and approvals give you visibility into that automated w...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/about-automation-rationale-and-approvals.md", "title": "About rationale, confidence, and approvals for issues" }
Overview With a manually started session, you give a task each time you want work done. With , you define a task once, and runs it automatically whenever the 's trigger fires. For example, you can use to: Triage incoming issues: automatically label new issues as a bug, an enhancement, or other, based on their cont...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/about-automations.md", "title": "About Copilot automations" }
Overview of With , can work independently in the background to complete tasks, just like a human developer. can: Research a repository Create implementation plans Fix bugs Implement incremental new features Improve test coverage Update documentation Address technical debt Resolve merge conflicts When you del...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/about-cloud-agent.md", "title": "About GitHub Copilot cloud agent" }
Where you can use Once you create , they become available to: on : The agents tab and panel, issue assignment, and pull requests in IDEs: , JetBrains IDEs, Eclipse, and Xcode You can use directly in , JetBrains IDEs, Eclipse, and Xcode. Some properties may function differently or be ignored between environments. ...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/about-custom-agents.md", "title": "About custom agents" }
[!NOTE] For an introduction to , see AUTOTITLE. Overview If you are a or subscriber, is disabled by default and must be enabled by an administrator before it is available for use. If you are a , , or subscriber, is enabled by default. Once enabled, you can use in any repository, provided that an administrator h...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/access-management.md", "title": "Managing access to GitHub Copilot cloud agent" }
About agents AI agents are autonomous systems that can evaluate their environment, make decisions, and take actions to complete tasks. Agents can break down complex tasks into steps, use various tools and resources, plan their approach, and adapt based on human feedback until they accomplish their assigned objective. A...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/agent-management.md", "title": "About agent management" }
These articles provide an overview of . For instructions on configuring and using , see the how-to articles under AUTOTITLE.	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/index.md", "title": "Concepts for GitHub Copilot cloud agent" }
Overview The agent can use tools provided by local and remote MCP servers. Some MCP servers are configured by default to provide the best experience for getting started. For more information on MCP, see the official MCP documentation. For information on some of the currently available MCP servers, see the MCP servers r...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/mcp-and-cloud-agent.md", "title": "Model Context Protocol (MCP) and GitHub Copilot cloud agent" }
is an autonomous agent that has access to your code and can push changes to your repository. This entails certain risks. Where possible, has applied appropriate mitigations. This gives a strong base of built-in security protections that you can supplement by following best practice guidance. Unvalidated code can int...	{ "source": "github-docs/copilot/concepts/agents/cloud-agent/risks-and-mitigations.md", "title": "Risks and mitigations for GitHub Copilot cloud agent" }
Introduction reviews code written in any language, and provides feedback. It reviews your code from multiple angles to identify issues and suggest fixes. You can apply suggested changes with a couple of clicks. This article provides an overview of . To learn how to request a code review from , see AUTOTITLE. Availabi...	{ "source": "github-docs/copilot/concepts/agents/code-review.md", "title": "About GitHub Copilot code review" }
An extension lets you add your own capabilities to . Each extension is a small Node.js module that runs as a separate process alongside your interactive session and connects back to it. Through that connection an extension can add: Tools that can call while it works on your behalf. Slash commands that you run yourse...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/about-cli-extensions.md", "title": "About extensions for {% data variables.copilot.copilot_cli %}" }
Introduction The command-line interface (CLI) for allows you to use directly from your terminal. You can use it to answer questions, write and debug code, and interact with . For example, you can ask to make some changes to a project and create a pull request. gives you quick access to a powerful AI agent, without ...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/about-copilot-cli.md", "title": "About GitHub Copilot CLI" }
In addition to any you define yourself, includes a set of pre-built . See Built-in agents. Built-in agents In addition to the main agent, which processes your request when you submit a prompt, includes the following built-in agents which the main agent can run as subagents to assist with common development tasks. ...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/about-custom-agents.md", "title": "About custom agents" }
This article explains the concepts around remote control of sessions. For instructions on how to enable remote control, see AUTOTITLE. When remote control helps By default, sessions are only steerable from your local machine. However, you can enable remote control of the session. Remote control is useful when you wa...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/about-remote-control.md", "title": "About remote control of {% data variables.copilot.copilot_cli %} sessions" }
Overview Typically, when you use interactively, you submit a prompt and then wait for to respond before giving the next instruction. This back-and-forth interaction continues until the task is done. Autopilot mode allows to work through a task without waiting for your input after each step. Once you give the initial...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/autopilot.md", "title": "Allowing GitHub Copilot CLI to work autonomously" }
Introduction When you work in an interactive session, you can press <kbdEsc</kbd or <kbdCtrl</kbd+<kbdC</kbd to control what is doing. Both keypresses can cancel operations, but they work slightly differently: <kbdCtrl</kbd+<kbdC</kbd acts immediately, without a confirming second press—removing any queued prompts fi...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/cancel-and-roll-back.md", "title": "Canceling a {% data variables.copilot.copilot_cli %} operation and rolling back changes" }
Introduction Every time you use , your session data is recorded on your local machine. This includes your prompts, 's responses, the tools that were used, and details of files that were modified. By default, session data is also synced to your account. This lets you query all of your past sessions, including sessions ...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/chronicle.md", "title": "About {% data variables.copilot.copilot_cli %} session data" }
Introduction is a terminal-based AI agent that can answer questions, plan work, and complete tasks on your behalf. It’s designed to be highly extensible, and there are various ways in which you can customize its behavior and extend its capabilities. This article explains the difference between: Custom instructions ...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/comparing-cli-features.md", "title": "Comparing GitHub Copilot CLI customization features" }
About the context window When you use , every message you send, every response from , every tool call and its result, and the system instructions that define 's behavior are all held in a context window. The context window is the total amount of information that the AI model can consider at one time when generating a r...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/context-management.md", "title": "Managing context in {% data variables.copilot.copilot_cli %}" }
Authentication and billing options When you run in a workflow, you can authenticate using either a (PAT) or the built-in GITHUBTOKEN. Using a PAT: The workflow authenticates as the user who created the PAT. are drawn from that user's seat entitlements, and their license determines which models and features are av...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/copilot-cli-in-github-actions.md", "title": "About using Copilot CLI in GitHub Actions" }
Introduction The /fleet slash command in is designed to take an implementation plan and break it down into smaller, independent tasks that can be executed in parallel by subagents. This allows for faster completion of complex requests that involve multiple steps. This article gives an overview of the /fleet slash comm...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/fleet.md", "title": "Running tasks in parallel with the `/fleet` command" }
Introduction The Language Server Protocol (LSP) is an open standard used for communication between a code editor and a language server. A language server is a process that provides language-specific features like go-to-definition and renaming a code symbol across your codebase. An "LSP server" is any language server th...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/lsp-servers.md", "title": "Using LSP servers with {% data variables.copilot.copilot_cli %}" }
Introduction 's /research slash command is a powerful tool for deep research and investigation. When you enter /research followed by details of what you want to know about, activates a specialized research agent that gathers and processes information from your codebase, from relevant repositories, and from the web. T...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/research.md", "title": "Researching with {% data variables.copilot.copilot_cli %}" }
Introduction Rubber duck is a built-in agent in that acts as a constructive critic. While working on a task, the main CLI agent for a session can pass its current plan, design, implementation, or tests over to the rubber duck agent for review. The rubber duck agent looks for blind spots, design flaws, and substantive ...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/rubber-duck.md", "title": "About the rubber duck agent" }
Introduction Connecting MCP servers and other external tools to is powerful, but every tool you add carries a cost: its definition takes up space in the model's context window, and a long menu of tools makes it harder for the agent to pick the right one. On-demand tool loading (or "tool search") prevents the context w...	{ "source": "github-docs/copilot/concepts/agents/copilot-cli/tool-search.md", "title": "Loading tools on demand with tool search" }
Introduction There are three ways to use in : the plugin, as an agent in JetBrains AI Assistant, and in the integrated terminal. Each entry point provides a different set of capabilities depending on how you prefer to work. Comparing entry points plugin in AI Assistant ------------ Best for Comprehensive...	{ "source": "github-docs/copilot/concepts/agents/copilot-in-jetbrains.md", "title": "Using GitHub Copilot in JetBrains IDEs" }
[!NOTE] This feature is currently in and is subject to change. As a developer joining an existing codebase, you typically read the repository's README, coding conventions, and other documentation to understand how the project works and how to contribute. This helps you submit good quality pull requests from the start....	{ "source": "github-docs/copilot/concepts/agents/copilot-memory.md", "title": "About GitHub Copilot Memory" }
Overview The AI Controls view provides a centralized platform where you can manage and monitor AI policies and agents across your enterprise. From the "Agents" page, you can: Manage the enterprise-level availability of agents like , , and Control who can manage your enterprise-level View and filter a list of agent...	{ "source": "github-docs/copilot/concepts/agents/enterprise-management.md", "title": "Agent management for enterprises" }
Introduction The 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 issues and pull requests, and manage the full development lifecycle—without context-switching between terminals, IDEs, and browser tabs. The app ...	{ "source": "github-docs/copilot/concepts/agents/github-copilot-app.md", "title": "About the GitHub Copilot app" }
What are hooks? Hooks are a way of executing custom shell commands at strategic points in an agent's workflow, such as when an agent session starts or ends, when you enter a prompt, or when a tool is called. Hooks receive detailed information about agent actions via JSON input, enabling context-aware automation. For ex...	{ "source": "github-docs/copilot/concepts/agents/hooks.md", "title": "About hooks for {% data variables.product.prodname_copilot %}" }
[!NOTE] integration is currently in . Introduction The coding agent and the integration use the Codex SDK and can be powered by your existing subscription. For more information about how works, see the documentation. coding agent Before you can assign tasks to coding agent, it must be enabled. See AUTOTITLE....	{ "source": "github-docs/copilot/concepts/agents/openai-codex.md", "title": "OpenAI Codex" }
Every license includes that are pooled across your enterprise. Budget controls let you govern how individual users draw from that pool and cap any additional spending once the pool is exhausted. This article explains what each control does, how the system evaluates them, and what happens when a limit is reached. Und...	{ "source": "github-docs/copilot/concepts/billing/budgets-for-usage-based-billing.md", "title": "Budgets for usage-based billing" }
offers multiple plans for individual developers, as well as a dedicated student offering, each designed to meet different needs based on your coding habits, interest in AI models, and desired level of flexibility. You can choose from the following plans. For developers looking to get started with . Includes up to 2,0...	{ "source": "github-docs/copilot/concepts/billing/individual-plans.md", "title": "About individual GitHub Copilot plans and benefits" }
Available plans offers the following plans for organization accounts: at per user per month, includes per user, and access to a broad model catalog. at per user per month, includes per user ( only), and priority access to new models and features. <!-- expires 2026-09-01 -- [!NOTE] Existing customers receiv...	{ "source": "github-docs/copilot/concepts/billing/organizations-and-enterprises.md", "title": "About billing for GitHub Copilot in organizations and enterprises" }
usage is measured in . All plans include a monthly allowance of . If you use up all of the credits included in your plan, you can purchase more and keep working. What are ? When you use , the interaction consumes tokens: input tokens (what's sent to the model), output tokens (what the model generates), and cached tok...	{ "source": "github-docs/copilot/concepts/billing/usage-based-billing-for-individuals.md", "title": "Usage-based billing for individuals" }
What are ? are the billing unit for usage in and . When someone in your organization uses , the interaction consumes tokens: input tokens (what's sent to the model), output tokens (what the model generates), and cached tokens (context the model reuses or stores). Each token is priced based on the model used, and the...	{ "source": "github-docs/copilot/concepts/billing/usage-based-billing-for-organizations-and-enterprises.md", "title": "Usage-based billing for organizations and enterprises" }
Overview is the AI-powered chat interface for . It allows you to interact with AI models to get coding assistance, explanations, and suggestions in a conversational format. can help you with a variety of coding-related tasks, like offering you code suggestions, providing natural language descriptions of a piece of co...	{ "source": "github-docs/copilot/concepts/chat.md", "title": "About GitHub Copilot Chat" }
About code referencing in JetBrains IDEs Code referencing for inline suggestions Code referencing for About code referencing in Code referencing for inline suggestions Code referencing for About code referencing on Code referencing for If you, or your organization, have allowed suggestions that match p...	{ "source": "github-docs/copilot/concepts/completions/code-referencing.md", "title": "GitHub Copilot code referencing" }
About code suggestions in in provides two kinds of code suggestions: Based on the edits you are making, both predicts the location of the next edit you'll want to make and what that edit should be. To enable , see AUTOTITLE. Ghost text suggestions offers coding suggestions as you type. Start typing in the edi...	{ "source": "github-docs/copilot/concepts/completions/code-suggestions.md", "title": "GitHub Copilot code suggestions in your IDE" }
About content exclusion for You can use content exclusion to configure to ignore certain files. When you exclude content from : Inline suggestions will not be available in the affected files. The content in affected files will not inform inline suggestions in other files. The content in affected files will not inf...	{ "source": "github-docs/copilot/concepts/context/content-exclusion.md", "title": "Content exclusion for GitHub Copilot" }
Overview of Model Context Protocol (MCP) You can use MCP to extend the capabilities of by integrating it with a wide range of existing tools and services. MCP works across all major surfaces—whether you're working in an IDE, using , working in the , or delegating tasks to an agent on . You can also use MCP to create ...	{ "source": "github-docs/copilot/concepts/context/mcp.md", "title": "About Model Context Protocol (MCP)" }
Benefit of indexing repositories 's ability to answer natural language questions and complete tasks in a repository context is optimized when the semantic code search index for the repository is up to date. will not use your indexed repository for model training. Semantic code search in When you start a conversation...	{ "source": "github-docs/copilot/concepts/context/repository-indexing.md", "title": "Indexing repositories for GitHub Copilot" }
let you organize the context that uses to answer your questions. can include repositories, code, pull requests, issues, free-text content like transcripts or notes, images, and file uploads. You can ask questions grounded in that context, or share the space with your team, or share publicly, to support collaboration...	{ "source": "github-docs/copilot/concepts/context/spaces.md", "title": "About GitHub Copilot Spaces" }
About usage metrics usage metrics help key stakeholders and decision-makers understand how their teams are adopting and using . By tracking usage patterns across the enterprise, you can measure engagement, identify opportunities to increase value, and assess how AI-assisted workflows influence pull request throughput...	{ "source": "github-docs/copilot/concepts/copilot-usage-metrics/copilot-metrics.md", "title": "GitHub Copilot usage metrics" }
is evolving rapidly, with new features and models released regularly. If you're an enterprise administrator, staying informed helps you make confident decisions about which capabilities to enable, when to adopt them, and how to manage risk across your organizations. This article provides guidance on navigating the lan...	{ "source": "github-docs/copilot/concepts/learning-about-new-features-and-models.md", "title": "Learning about new features and models" }
You can manage MCP server usage in your organization or enterprise by configuring a series of MCP policies on . Through these policies, you can allow or block MCP server usage entirely, or restrict access to a list of servers that you define in an MCP registry. MCP policy settings The following settings let you contro...	{ "source": "github-docs/copilot/concepts/mcp-management.md", "title": "MCP server usage in your company" }
Overview More than just a model picker, is an intelligent system delivering high quality results, better reliability, and one less decision to make as the model landscape rapidly evolves. Auto with task optimization [!NOTE] with task optimization is generally available in on the website, in , in , and in . with ...	{ "source": "github-docs/copilot/concepts/models/auto-model-selection.md", "title": "About {% data variables.product.prodname_copilot_short %} {% data variables.copilot.copilot_auto_model_selection_short %}" }
Local BYOK Various clients allow users to configure custom LLM keys locally. These keys are only handled client-side: they are stored locally and the associated models aren't available to other users. This mechanism removes dependency on 's API, making it suitable for air-gapped environments or users without subscri...	{ "source": "github-docs/copilot/concepts/models/bring-your-own-key.md", "title": "Bring your own key for GitHub Copilot" }
On and plans, the Default availability for released models policy will control whether unconfigured generally available (GA) models default to enabled or disabled. If this policy is enabled, users will benefit from the latest models without the need for administrator intervention. <!-- expires 2026-08-26 -- To give y...	{ "source": "github-docs/copilot/concepts/models/default-availability.md", "title": "About default availability of {% data variables.product.prodname_copilot_short %} models" }
About base models [!IMPORTANT] On March 18, 2026, designated as the base model. Base models apply only to and . A base model is the default AI model that uses when no other models are enabled. The base model is automatically enabled for all or accounts within 60 days after the model is designated as a base ...	{ "source": "github-docs/copilot/concepts/models/fallback-and-lts-models.md", "title": "Base and long-term support (LTS) models" }
If your enterprise uses in the US, you can enable a policy to ensure that users on your plan can only use models with FedRAMP Moderate certification. Available models Enabling the FedRAMP policy restricts users to the following models: Client version requirements Supported features Pricing changes Policy contro...	{ "source": "github-docs/copilot/concepts/models/fedramp-models.md", "title": "FedRAMP-compliant models for GitHub Copilot" }
Utility models are a small set of models that are automatically enabled for all users across every plan. They power background features such as the generation of commit messages or chat session titles, and they apply across surfaces: in IDEs, on , and in . How do utility models work? Utility models: Are not visible...	{ "source": "github-docs/copilot/concepts/models/utility-models.md", "title": "Utility models" }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.