Most "we added AI" announcements are noise. You squint, and underneath the launch copy it's the same chatbot bolted onto a sidebar, quietly shipping your data to someone else's model. This stretch of Forge releases is different, and the reason it matters isn't the AI itself. Everyone has good models now. The interesting part is where the work happens and where the data goes: agents that live inside Jira's  permissions and audit trail, model calls that never leave Atlassian's security boundary, and tooling that lets you build all of it without standing up your own infrastructure. That's the difference between a feature you can demo and one your security team will actually approve. We went through the releases as a team and pulled out what's worth your time. Here's what we found.

In short: 

• • Assign a Jira work item to an AI agent like you'd assign a teammate. It works inside your existing permissions and audit trail. (GA:Generally available)

  • Rovo MCP Gallery: Agents from Box, Canva, Figma, GitHub and more can now act inside your workflows over MCP, not just chat.

  • Forge LLMs API → Preview: Call Claude models from your app with no external keys and no data leaving Atlassian.

  • Forge MCP Server → GA: Point your coding agent at authoritative Forge docs so it writes real Forge code instead of guessing.

  • Forge custom fields: Now available as columns in Jira's new List View.

  • Teamwork Graph: Stitches Jira, Confluence and third-party tools into one queryable graph, now open to agents.

  

  Assign a work item to an AI agent and get a pull request back

This is the one that got the most reaction from us. Announced at Team '26 and now generally available, you can assign an AI agent to a Jira work item the same way you'd assign it to a teammate, straight from the Assignee field. The agents Atlassian highlights include its own Rovo Dev, the GitHub Copilot coding agent, and third-party tools like Cursor.

Why it matters: a chunk of backlog work is well-defined but boring, the kind of ticket that sits untouched for weeks. Handing that to an agent and getting a reviewable PR back changes the math on what's worth doing. The agent feature is the one we're most interested in putting through its paces ourselves.

The Rovo MCP Gallery: agents that act, not just answer

(Related: third-party agents have also reached Confluence in open bet you can @mention agents from tools like Lovable, Replit, Databricks and Gamma directly on a page and have them act on its context.)

The Forge LLMs API is now in Preview: AI in your app, data stays inside Atlassian

The manifest side is small. Declare the module:

modules:
  llm:
    - key: my-llm
      name: App LLM

And a call looks roughly like this (check the @forge/llm reference for exact signatures, since it's still a Preview API):

import { LLM } from '@forge/llm';

const response = await LLM.chat.completions.create({
  model: 'claude',
  messages: [
    { role: 'user', content: 'Summarize this Jira issue in one sentence' }
  ],
});

The Forge MCP Server is GA:  

build with AI

If you want the full kit, Atlassian also ships a Forge AI plugin that bundles the MCP server with skills for scaffolding, pre-deploy review, and debugging. For a team standardizing on AI-assisted development, this is the difference between an agent that knows Forge and one that pattern-matches from stale training data.

A small but useful win: custom fields in Jira's List View

Not everything in a release is a headline. Forge custom fields now render as columns in Jira's new List View. If you define a formatter expression in your manifest, the column shows the formatted value instead of the raw stored one:

modules:
  jira:customField:
    - key: progress-field
      name: Progress
      description: Shows task progress
      type: number
      formatter:
        expression: "`${'='.repeat(value / 10).padEnd(10, '=')} (${value}%)`"

That turns a plain number into a little progress bar with a percentage, so scanning across issues gets much easier on the eyes. Without a formatter you just get the raw value, so defining one is the whole point. Two limits to know: it's read-only (open the issue to edit a value) and text-only (no Custom UI or UI Kit rendering in the column). The same behavior applies to both jira:customField and jira:customFieldType.

Where it's all heading: the Teamwork Graph

This is the architectural one and it's worth understanding even if you don't build on it tomorrow, because it's the layer the whole AI story quietly depends on. The Teamwork Graph is Atlassian's unified, graph-structured data layer. Jira issues, Confluence pages, and third-party objects used to live on isolated islands; the graph stitches them into one model, now reportedly past 150 billion connections.

What's new at Team '26 is that the graph is opening up to agents: a Teamwork Graph CLI with hundreds of commands, plus Teamwork Graph tools delivered through Rovo's MCP server, so coding agents and compliant assistants can query, and in some cases write back to, work and relationships across products through a single interface.

On the write side you declare a connector with the object types it owns:

modules:
  graph:connector:
    - key: gdrive-connector
      name: Google Drive
      objectTypes:
        - atlassian:document

And a read starts from a node and follows an edge here, from a user to their teams:

import api from '@forge/api';

const cypher = `
  MATCH (user:IdentityUser {ari: $id})-[:user_is_in_team]->(team:IdentityTeam)
  RETURN collect(distinct team) as teams
`;

const res = await api.asUser().requestTeamworkGraph({
  cypherQuery: cypher,
  params: { id },
});

Our honest take: the graph tech itself isn't new, and plenty of platforms are building graphs to anchor their AI strategies. The real bet here is ecosystem scale and openness. The comparison people reach for is Microsoft Graph, which nailed the unified layer but keeps its gravity inside M365. Atlassian's bet is explicitly open: it wants your non-Atlassian tools in the graph too. And where enterprise search crawls everything so you can search your company, the Teamwork Graph leans on semantic relationships. Knowing that a PR closes an issue, which blocks an OKR, is high-fidelity context and that's what makes AI agents deterministic rather than just chatty.

Also worth knowing 

Forge Feature Flags let you ship code without releasing it to everyone, and without a redeploy. Wrap new code in a flag, keep it off by default, then enable it per user, site, environment, or rollout percentage from the Developer Console. It pairs neatly with the agent workflow above: let an agent's PR ship behind a flag and roll it out on your terms.

Where this leaves us