GitHub Copilot for Jira Now Writes Code and Opens Pull Requests Autonomously

GitHub just hit general availability on one of the more practically useful AI integrations in the developer toolchain: GitHub Copilot for Jira. The pitch is simple but meaningful: assign a Jira ticket to Copilot, watch it write code and open a pull request, and steer the whole thing without ever leaving Jira. No tab-switching, no context loss, no manual copy-pasting of requirements into a chat window.

From ticket to pull request, in one place

You can assign Jira issues to GitHub Copilot's coding agent, an asynchronous, autonomous agent, and get AI-generated draft pull requests created in your GitHub repository. The agent is not a chatbot you prompt interactively. It operates as a cloud-based background worker that creates branches, writes code, runs tests, and opens PRs autonomously, making it the first mainstream tool to industrialize asynchronous AI coding at enterprise scale.

The GA release ships three new capabilities on top of what was already in preview:

• Live progress streaming: You can now monitor the coding agent's progress directly within your Jira issue in real time. As the agent works, status updates stream back to the Jira ticket so you can follow along without switching to GitHub.
• Post-session steering: After the agent completes its work and opens a draft pull request, you can now provide follow-up instructions directly in the Jira chat panel. The agent will continue working on the same pull request rather than creating a new one. This matters because it keeps your review history clean and avoids a proliferation of orphaned PRs.
• Simplified onboarding: The GA release simplified onboarding by reducing the configuration steps needed to connect a GitHub organization and its repositories to the Jira app, so an admin can wire it up without leaving Jira.

What shipped during the preview

Since launching the public preview in March 2026, GitHub shipped a series of enhancements based on user feedback, including model selection, Confluence context via MCP, custom agents, custom fields, space-level guidance, and review request notifications in Jira. A few of those deserve a closer look.

The Confluence context via MCP is particularly interesting. MCP (Model Context Protocol) is an open standard that lets AI agents call external tools and data sources through a structured interface. The agent can query databases, read Confluence or Notion documentation, check CI/CD pipeline status, pull Figma design specs, and query internal knowledge bases, all during a single task execution. In practice, this means the agent can implement features that reference internal documentation without the developer having to copy-paste context into an issue.

Custom agents are also worth noting. You can specify in the Jira ticket a custom agent from your GitHub repository to be used when fulfilling the task, allowing teams to tailor Copilot cloud agent's behavior to their specific needs, directly from the Jira ticket. And the agent can read the content of Atlassian custom fields, such as acceptance criteria, and include that context when working on your issue, meaning the agent receives richer, more structured context.

The bigger picture: AI that lives where the work is

The real story here is not just about a new feature. It is about where AI agents are being anchored in the software development lifecycle. Historically, Copilot lived in the IDE, close to the code. This integration moves the trigger point upstream to where work is planned and tracked. Project managers and developers who live in Jira can now drive code changes without switching tabs, see the agent's progress, and steer it without losing the existing pull request. Cutting the back-and-forth between Jira and GitHub is the point of the launch.

This also signals a broader pattern in the industry: AI coding agents are being embedded directly into project management tools, not just IDEs. The integration competes with a growing ecosystem of third-party connectors on the Atlassian Marketplace, but the official GitHub-built version has a key advantage: it is free and first-party, meaning it gets updates alongside Copilot itself rather than depending on a third-party maintainer.

What you need to get started

The requirements are worth knowing before you get excited. You must have a GitHub account with access to Copilot through a paid Copilot plan, a Jira Cloud account, Jira must be an AI-enabled app, and Rovo must be activated for your organization. Rovo is Atlassian's AI platform layer, so this is not a zero-cost add-on for every Jira user.

The workflow itself is straightforward once set up:

1. Open or create a work item in Jira that contains clear requirements you want to delegate to Copilot cloud agent. Specify a repository you want Copilot to work in by mentioning it in the work item description or in a comment. Then assign GitHub Copilot to the work item, or mention @GitHub Copilot in a comment.
2. Once Copilot cloud agent has started working on the pull request, a comment will appear in the chat panel in Jira. The user who initiated the agent session can view progress there.
3. You can follow up with further instructions for Copilot using the Continue in Chat button under the Agents heading to chat directly with Copilot and have updates made to the current pull request.

One thing that does not change: humans still review the code. A Jira issue triggers an agent session, progress stays visible to non-GitHub stakeholders, and humans still review the generated pull request before it lands. The agent handles the mechanical work; the judgment call on whether the code is correct and safe stays with the team.

The app is available now on the Atlassian Marketplace as a free install. If you already have the preview version, update to the latest to get the GA features. Full setup instructions are in the official GitHub docs. For teams already running Copilot Enterprise and Jira Cloud, this is one of the lower-friction ways to start putting an autonomous coding agent into a real production workflow.