Skip to content

// Engineering - November 9, 2026

Copilot coding agent: work from a task board.

GitHub Copilot coding agent, now called Copilot cloud agent, works on a task in the background and opens a draft pull request for review. To work from a board outside GitHub, add the board's MCP server in the repository's Copilot settings, store its key as a COPILOT_MCP_ secret, and allowlist only the tools it needs.

What is GitHub Copilot coding agent?

Copilot coding agent is GitHub's background coding agent: you give it a task, it works in its own environment, and it hands back a draft pull request for a person to review. GitHub has since renamed it Copilot cloud agent. A GitHub changelog entry from April 23, 2026 mentions "the Copilot coding agent to Copilot cloud agent rename", and the docs now use the new name throughout. This post uses both names.

You start a task by assigning a GitHub issue to Copilot, from the Agents tab in a repository, or from chat. GitHub's overview says a session runs either on a GitHub Actions runner or in a cloud sandbox. The sandbox is the newer "Copilot in the cloud" experience, open to paid Copilot plans since October 28, 2026. Three limits from the same page shape the work:

  • One branch and one pull request per task.
  • A session on GitHub Actions stops after 59 minutes, and that limit "cannot be extended or bypassed".
  • It only works on repositories hosted on GitHub.

GitHub's risks and mitigations page adds the review rules: Copilot "cannot mark its pull requests as 'Ready for review' and cannot approve or merge a pull request", and the person who asked for the pull request can't approve it either.

Why connect Copilot to a task board outside GitHub?

Because the issue Copilot works from is only one part of the work. GitHub's best-practices guide says "think of the issue you assign to Copilot as a prompt." If your team plans on another board, that board holds the real brief, the acceptance criteria and the review step. It may also hold work for Claude Code or Cursor that never reaches a GitHub issue.

GitHub has native Copilot integrations for some trackers. As of November 2026, its integrations page lists Jira, Linear, Azure Boards, Slack and Microsoft Teams. For any other board, the route is the Model Context Protocol (MCP). Copilot calls the board's MCP tools during the session to read a card, comment on it and move it, and the team sees every agent's work in one place.

How do you add an MCP server to Copilot coding agent?

A repository administrator pastes a JSON configuration into the repository's Copilot settings, and adds the server's key as an Agents secret whose name starts with COPILOT_MCP_. These are the steps from GitHub's guide to configuring MCP servers for a repository, filled in for the Flux MCP server:

  1. Make a Flux API key. In Flux Settings, create a key. Leave Write off for a read-only setup, or turn it on if Copilot should comment on and move cards. MCP works on every Flux plan, including Free, and an agent using a key never takes a seat.
  2. Add the secret. In the repository, open Settings, then Secrets and variables, then Agents, and add a secret named COPILOT_MCP_FLUX_API_KEY with the key as its value. GitHub's secrets page says secrets with this prefix "are only available to MCP servers", so the commands Copilot runs in its shell never see the key.
  3. Add the server. In Settings, under "Code, planning, and automation", open Copilot, then MCP servers, paste the configuration below and click Save MCP configuration.
  4. Check that it started. Assign a test issue to Copilot, open the session with View session, and expand the Start MCP Servers step. GitHub says the server's tools are listed at the bottom of that log when it started correctly.
{
  "mcpServers": {
    "flux": {
      "type": "http",
      "url": "https://flux.umin.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer $COPILOT_MCP_FLUX_API_KEY"
      },
      "tools": ["get_board", "get_card", "add_comment", "move_card"]
    }
  }
}

Flux's MCP server is a remote server that speaks streamable HTTP and reads a Bearer flux_... key from the Authorization header, so "type": "http" with a header is the right shape. GitHub's docs say all string fields except tools and type support substitution, and that header values can be a substitution reference such as $COPILOT_MCP_API_KEY. Their examples pass the whole value, and none shows a secret inside a longer header like Bearer $.... The Bearer $COPILOT_MCP_FLUX_API_KEY form is our reading of that rule, and we have not run it in a live Copilot session. If the log shows the Flux server failing with a 401, the header may not have been substituted, so check the secret's name first. If it still fails, store the whole Bearer flux_... string as the secret and use "Authorization": "$COPILOT_MCP_FLUX_AUTH".

Which Flux tools should Copilot coding agent get?

Only the ones the task needs. GitHub warns that once a server is configured, Copilot "will be able to use the tools provided by the server autonomously, and will not ask for your approval before using them". Its docs strongly recommend allowlisting specific read-only tools. The Flux server has 12 tools:

Tool What it does Give it to Copilot?
get_boardColumns and card IDs for one boardYes, to find the card and the column IDs
get_cardFull card with description and commentsYes, this is the brief
add_commentPosts a comment on a card (Write)Yes, for progress notes
move_cardMoves a card to any column on its board (Write)Yes, to reach Needs review
update_cardRewrites title, description, due date or priority (Write)No. The brief should stay as a person wrote it
create_card, create_column, reorder_cardsChange the board itself (Write)No, unless Copilot plans work
list_workspaces, list_boards, list_cards, search_cardsBrowse and search (read)Rarely needed when the task names the card

The tools list and the key's scope are two separate limits. The list decides which tools Copilot can call. The key decides what the server allows: with a key that has no Write scope, every write tool answers "Error: write scope required", whatever the list says. Treat the key like any other credential, and revoke it in Flux Settings if it leaks.

How does Copilot pick up a card from the board?

Name the card in the task, and put the board rules in the repository's instruction file. According to GitHub's best-practices guide, Copilot cloud agent reads .github/copilot-instructions.md, AGENTS.md and a root CLAUDE.md, among others. (Our AGENTS.md vs CLAUDE.md guide covers how to share one set of rules across agents.) Add a section like this to .github/copilot-instructions.md:

## Flux board

Tasks live on a Flux board, reached through the flux MCP server.

- When a task names a Flux card and board, call get_board with the
  board ID, find the card by its humanId, then call get_card with the
  card's id. The description is your brief and its acceptance
  criteria say when you are finished.
- Start the pull request description with the line
  "Flux card: <the card's UUID, the id field from get_card, not the
  humanId>".
- When you start, add_comment on the card: "[copilot] Started."
- When the work is ready for review, add_comment with what you
  changed and how you tested it, then move_card to the Needs review
  column. get_board lists the column IDs.
- Never move a card to Done. A person does that after review.

The task itself can then stay short. This issue body points Copilot at the card. The board ID is the short ID in the board's URL, and PROJ-42 is the card's humanId, shown on the card:

Flux card PROJ-42 on board k3J9xQ2a.

Read the card with the flux tools and do the work it describes.

Three details come from Flux's MCP code. get_board accepts the board's short ID and returns every card's id and humanId. get_card, add_comment and move_card all take the card's id, a UUID, so look the card up by its humanId in get_board first. And comments made with a key show under the name of the Flux account that made the key, so the [copilot] prefix tells readers which agent wrote what. For repository-level servers that need authentication, GitHub suggests "a service account for Copilot rather than personal credentials". In Flux, that means making the key from a separate account. That account needs the member role in the workspace, and paid plans bill each member.

Use the four columns from our kanban board for AI agents guide: Backlog, In Progress, Needs review and Done. Copilot takes a card as far as Needs review. A person reviews the pull request and moves the card to Done. Flux does not enforce column order, and move_card can move a card to any column, so "never move to Done" is a rule Copilot follows, not a lock.

With a small GitHub Actions workflow that reads the "Flux card:" line from the pull request description and sets the card's GitHub PR field through the Flux REST API. Flux cards have a GitHub PR field, but the MCP update_card tool can't set it. The REST endpoint PATCH /api/cards can, with a key that has the Write scope:

name: Link pull request to Flux card
on:
  pull_request:
    types: [opened, edited]

jobs:
  link:
    runs-on: ubuntu-latest
    steps:
      - name: Set the card's GitHub PR field
        env:
          FLUX_API_KEY: ${{ secrets.FLUX_API_KEY }}
          PR_BODY: ${{ github.event.pull_request.body }}
          PR_URL: ${{ github.event.pull_request.html_url }}
        run: |
          CARD=$(printf '%s' "$PR_BODY" | grep -oiE 'flux card: [0-9a-f-]{36}' | head -n 1 | awk '{print $3}' || true)
          if [ -z "$CARD" ]; then echo "No Flux card line, skipping"; exit 0; fi
          curl -sSf -X PATCH https://flux.umin.ai/api/cards \
            -H "Authorization: Bearer $FLUX_API_KEY" \
            -H "Content-Type: application/json" \
            -d "$(printf '{"cardId":"%s","githubPrUrl":"%s"}' "$CARD" "$PR_URL")"

Store this key as an Actions secret named FLUX_API_KEY. It is a different store from the Agents secrets, and GitHub's secrets page says Copilot "does not have access to GitHub Actions, Codespaces, or Dependabot secrets". Workflows don't run on Copilot's pull requests until someone with write access clicks Approve and run workflows, unless you turned that off. So the card gets its link only after someone with write access approves the run. Check the pull request for changes under .github/workflows/ before you approve, because the run can read FLUX_API_KEY. Unlike changes made over MCP, this REST update is written to the Flux activity log. For more ways to drive cards from GitHub events, see our GitHub integration guide.

What doesn't work yet?

Five things to know as of November 2026: Copilot code review won't call Flux's tools, Copilot uses MCP tools only, MCP changes skip the Flux activity log, the firewall covers the shell rather than MCP servers, and card text becomes part of the prompt.

  • Copilot code review skips Flux's tools. Code review shares the repository MCP configuration, but it only calls tools that set readOnlyHint: true. Flux's tools declare no annotations as of November 2026, so only the cloud agent uses them.
  • Tools only, no OAuth. Copilot ignores MCP resources and prompts, and repository settings don't support remote servers that use OAuth. Neither affects Flux, which offers tools only and takes an API key in a header.
  • The comments are the record. Comments and moves Copilot makes over MCP are not written to the Flux activity log. The signed comments, the pull request and the Copilot session log are what a reviewer reads.
  • The firewall covers the shell, not MCP servers directly. GitHub's firewall page says the firewall "only applies to processes started by the agent via its Bash tool" and not directly to MCP servers. The Flux tools themselves are not blocked by the firewall. You only need to allowlist flux.umin.ai if a command Copilot runs in its shell, such as a curl to the Flux API, triggers a firewall warning on the pull request.
  • Card text is part of the prompt. GitHub filters hidden characters, such as HTML comments, out of issues and comments before Copilot sees them. Its docs don't say the same for MCP tool results, and get_card also returns the card's comments, so anyone who can edit or comment on a card can brief Copilot.

When the pull request lands in Needs review, review it like any other contribution. Our code review checklist for AI agent pull requests lists what to check first.

// FAQ
06 questions
01

Is Copilot coding agent the same as Copilot cloud agent?

+

Yes. GitHub renamed Copilot coding agent to Copilot cloud agent. Its changelog of April 23, 2026 refers to "the Copilot coding agent to Copilot cloud agent rename". The docs now use the new name.

02

Can Copilot coding agent use MCP servers?

+

Yes. A repository administrator adds them as JSON under Settings, Copilot, MCP servers. Local servers and remote HTTP or SSE servers both work. Copilot uses only the tools, not resources or prompts. It calls the tools you allow without asking first, and remote servers that need OAuth are not supported in repository settings as of November 2026.

03

How do I pass an API key to an MCP server in Copilot?

+

Add an Agents secret, at repository or organization level, whose name starts with COPILOT_MCP_, such as COPILOT_MCP_FLUX_API_KEY. Then reference it in the MCP configuration as $COPILOT_MCP_FLUX_API_KEY in a header or environment value. GitHub passes those secrets only to MCP servers, not to the commands Copilot runs.

04

Can I give Copilot an MCP server just for myself?

+

Yes, with a personal MCP server, set up from the Customize menu on github.com/copilot. GitHub's docs say personal servers support key-based authentication only and work only in cloud sandbox sessions. Sessions that run on GitHub Actions don't get personal servers, so for those, use the repository configuration.

05

Will Copilot code review use my board's MCP tools?

+

Only tools that declare the MCP annotation readOnlyHint as true. Copilot code review shares the repository MCP configuration but skips any tool without it. As of November 2026, Flux's MCP tools declare no annotations, so Copilot code review does not call them. Copilot cloud agent does.

06

Does Flux have a native GitHub Copilot integration?

+

No. Flux connects to Copilot the same way it connects to Claude Code or Cursor: through its remote MCP server at https://flux.umin.ai/api/mcp with a Flux API key. GitHub's own native Copilot integrations, as of November 2026, are Jira, Linear, Azure Boards, Slack and Microsoft Teams.

// One board, every agent

Copilot writes the code. Your board keeps the brief.

Connect GitHub Copilot, Claude Code and Cursor to one Flux board over MCP. Each agent works from a card and stops at Needs review. Free to start, and agents that connect with an API key never take a seat.