How to Generate a GitHub Personal Access Token for Copilot and AI Agents

Developers are increasingly pointing autonomous AI agents and coding assistants, such as Claude Code, Cursor, Cline, Devin, or custom agent scripts, directly at their code repositories. While these tools accelerate software development by writing code and managing repositories autonomously, they introduce severe security challenges when configured with legacy authentication methods. If you connect an AI agent to a codebase using a classic GitHub personal access token with account-wide permissions, you are handing over control of your entire GitHub account to an external interpreter. A single prompt injection vulnerability, a malformed local configuration file, or an agent looping out of control can result in the accidental deletion of critical repositories, data exfiltration, or unauthorized API operations.

The resolution to this security risk is not to block AI tools entirely, but to enforce repository-scoped, fine-grained access tokens that restrict exactly what an agent can read, write, and execute. In this guide, we walk through how to create a GitHub personal access token scoped to the precise permissions required for AI agents and GitHub Copilot, ensuring your automation remains secure. You can manage these settings directly in your GitHub Developer settings.

• How to Connect Devin AI to GitHubDevin AI's GitHub integration is a full GitHub App install with nine read scopes and eight read-write scopes, not a...
• How to Run Cline in GitHub CodespacesRunning Cline in GitHub Codespaces lets developers spin up cloud-hosted container environments containing the AI coding...
• GitHub Copilot Personal Access Token Permissions for MCPSetting up a GitHub Model Context Protocol (MCP) server with administrative credentials exposes your entire account...
• Best Copilot Builder Frameworks for Developers in 2026Copilot builder frameworks let developers embed context-aware AI assistants directly into their products. This guide...
• How to Use MCP Servers with GitHub CopilotGitHub Copilot's MCP integration lets Copilot Chat connect to external MCP servers for file storage, databases, and...
• The Best Storage for GitHub Copilot Workflows: Object Storage vs Intelligent WorkspacesEvaluating storage for GitHub Copilot workflows requires looking beyond raw gigabytes to active context delivery. While...

More on this subject: GitHub Copilot (89 guides)

A GitHub Personal Access Token (PAT) is an alternative to password authentication used to verify identity for Git operations, REST API requests, and third-party AI tool integrations. When you interact with the GitHub API or execute Git commands from an automated environment, GitHub requires token-based authentication because password logins for these operations have been completely disabled.

GitHub provides two distinct formats for these credentials:

Personal Access Tokens (Classic): These legacy tokens (prefixed with ghp_) grant access at the account level. A classic token with the repo scope has unrestricted access to all repositories owned by the user, including private code. This all-or-nothing approach creates a massive security vulnerability when shared with AI agents that generate code dynamically.

Fine-Grained Personal Access Tokens: Introduced to enforce the principle of least privilege, fine-grained tokens (prefixed with github_pat_) allow you to restrict permissions to specific repositories and define granular access for individual resources. Unlike classic tokens, fine-grained personal access tokens expire automatically after a maximum of 366 days, which represents a mandatory limit of 1 year. This policy ensures that inactive credentials do not remain valid indefinitely. GitHub security audits strongly recommend repository-scoped tokens over account-wide classic tokens for all modern integrations. For a complete overview of token types, refer to the GitHub documentation on managing personal access tokens.

Generating a fine-grained token requires navigating to the developer settings within your GitHub profile. Follow these navigation steps to set up a new token:

1. In the upper-right corner of any page on GitHub, click your profile picture, then click Settings.
2. Scroll to the bottom of the left sidebar and click Developer settings.
3. Under the Personal access tokens section in the left sidebar, click Fine-grained tokens.
4. Click Generate new token.
5. Under Token name, enter a descriptive name that identifies the tool or agent using the token.
6. Under Expiration, select the lifetime for the token. The configurable range is 1 to 366 days, with a default of 30 days. Choose the shortest practical lifetime to limit exposure.
7. Under Resource owner, select the personal account or organization that owns the repositories the agent needs to access.
8. Under Repository access, select Only select repositories and choose the specific codebases the agent is authorized to work on. Avoid choosing All repositories unless absolutely necessary.
9. Configure the specific API scopes under the permissions sections as detailed in the following step, then scroll to the bottom and click Generate token.
10. Copy the generated token immediately. It is prefixed with github_pat_ and will not be displayed again once you navigate away from the page.

A common pitfall when generating personal access tokens is omitting the specific scopes required for AI agent operations, which results in authentication errors during runtime. AI agents do not just read code, they often need to query seat allocations, manage pull requests, or write metadata. Ensure you configure the following scopes based on your tool's requirements:

Repository Code Access: Select the Repository permissions dropdown. Under Contents, select Read & Write if the agent needs to commit code changes, create branches, or push updates. Select Read-only if the agent is acting purely as a code reviewer or RAG assistant. The Metadata permission is automatically set to Read-only when you select contents.

Pull Requests and Collaboration: Under Repository permissions, set Pull requests to Read & Write if the agent needs to open pull requests, merge branches, or submit reviews. Set Issues to Read & Write if the agent is responsible for creating issues, tracking tasks, or posting comments on code reviews.

Copilot Integration Scopes: If the agent queries Copilot configuration or seat allocations, navigate to the Account permissions section. Under Copilot Requests, set the access level to Read-only. Additionally, for cloud-based agents, you may need to navigate to Repository permissions and set Copilot agent settings to Read-only to allow the agent to fetch repository-level rules.

Organization-Level Polling: If the agent is running at the team level, organization owners can enforce policies that restrict fine-grained personal access tokens. Organizations can set a maximum token lifetime policy or require explicit administrative approval before any fine-grained token can access organization repositories.

Once you have generated your fine-grained token, you need to integrate it with the environment where your AI agents run. While developers often start by running agents locally, scaling agentic workflows across a team requires a shared, persistent workspace. Traditional file storage tools like Google Drive or Dropbox are designed primarily for human file synchronization and lack native API hooks and context indexing for AI.

Fast.io provides a collaborative cloud workspace platform designed for human-agent teams. Instead of managing files on local disks, agents and human developers share the same workspaces. Once you enable Intelligence Mode on a Fast.io workspace, files are automatically indexed for RAG chat and hybrid search. This hybrid search combines exact full-text matching with semantic meaning, allowing agents to query document contents and search by metadata values extracted via Metadata Views.

To connect your AI agents to a Fast.io workspace, you can use the official Model Context Protocol (MCP) server. Fast.io exposes an MCP server over Streamable HTTP at https://mcp.fast.io/mcp or with Bearer authentication at https://mcp.fast.io/mcp/key, as well as a legacy SSE transport at https://mcp.fast.io/sse. Agents configure access by declaring the server in their configuration file. For example, in a Cline configuration file (typically cline_mcp_settings.json), you define:

{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer <YOUR_FASTIO_API_KEY>"
      }
    }
  }
}

This MCP integration allows agents to read and write files directly within the shared workspace. Fast.io preserves a complete, per-file version history for all concurrent agent writes, ensuring that any erroneous file modifications can be audited and restored. When an agent finishes its work, the platform supports ownership transfer, allowing the agent to hand the workspace over to a human team member while retaining admin permissions. Fast.io is built on usage-based credits | plans include Starter at $29/mo, Business at $99/mo, and Growth at $299/mo, with every organization starting on a 14-day free trial that requires a credit card. For more details on team features, explore our agent storage guide.

Connect your GitHub personal access token to Fast.io workspaces

Securely share repository access, manage code versions, and collaborate with your AI agents in persistent, intelligent workspaces. Start your 14-day free trial (credit card required) on Starter at $29/mo, Business at $99/mo, or Growth at $299/mo.

Start 14-Day Trial

When running AI agents with GitHub tokens, you may encounter permission errors. Identifying the root cause of these issues helps maintain stable automation:

HTTP 403 Forbidden Errors (Header Format): This is the most common integration issue. Legacy classic tokens are authenticated using the token prefix, but fine-grained tokens require the Bearer token format in the HTTP authorization header. If your agent uses Authorization: token github_pat_..., GitHub will return a 403 Forbidden error. Update the agent configuration or request library to use Authorization: Bearer github_pat_....

HTTP 401 Unauthorized Errors (SSO Authorization): If your token needs to access repositories owned by an organization that enforces SAML Single Sign-On (SSO), the token must be explicitly authorized. Navigate to Settings, select Developer settings, click Fine-grained tokens, click on your token, and select Authorize next to the target organization.

Scope Insufficiency (403 on Commits): If your agent can fetch code but fails to push changes or create branches, check the repository scopes. Ensure the Contents permission is set to Read & Write rather than Read-only. Remember that updating scopes requires regenerating the token and updating the agent environment variables.