Atlassian Release Notes

What's changing

On 30 Nov 2026 Git requests authenticated using OAuth2.0 via the Git Credential Manager (GCM) will be blocked for versions prior to 3.0.0. This is caused by the lack of support for rotating OAuth refresh tokens, which have recently begun being enforced for Bitbucket’s OAuth 2.0 implementation. See:  https://developer.atlassian.com/cloud/bitbucket/changelog/#CHANGE-3052 . Atlassian contributed changes to the open source project to include support for the rotating refresh token model, which was bundled in the v3.0.0 release ( https://github.com/git-ecosystem/git-credential-manager/releases/tag/v3.0.1 )

What you need to do

• If
  • Action/s Required?
• You are NOT using Git Credential Manager
  • No action is required
• You ARE using Git Credential Manager configured with personal access tokens
  • No action is required
• You ARE using Git Credential Manager configured with OAuth2.0
  • You must upgrade Git Credential Manager to a version 3.0.0 or higher by 30 Nov 2026 if you wish to continue to authenticate Git using this mechanism. Simply upgrading the version should ensure seamless authentication.

Attached file

Note: Impacted users will see a message after each git push operation prior to upgrade.

Close the loop between the code your team builds and the quality you ship by bringing an intelligent, assignable agent directly into your Jira workflow.

Today, teams are caught between high-maintenance test suites that break easily and generic AI tools that lack delivery context. When testing is disconnected from where work is planned, teams lose sight of user journeys, acceptance criteria, and release scope. The result is blind spots, late-stage defects, noisy test suites, and costly handoffs across product, engineering, and QA.

Getting quality right in an AI-native delivery cycle requires grounding testing in the requirements and decisions your team collaborates on every day.

That’s where BearQ for Jira comes in.

BearQ is an assignable agent that brings intelligent, end-to-end testing directly into the delivery workflow. Acting as an AI teammate assigned to Jira work items, BearQ explores user journeys, generates adaptive test coverage, catches defects early, and closes the loop between the code agents write and the quality your team delivers.

How it works

Ground testing in real delivery context

Traditional testing often starts with disconnected tickets, stale specs, or clunky handoffs. BearQ flips this model by turning Jira work items into living test context.

Once code is generated and a PR or preview environment is ready, assign the work item directly to BearQ or @mention BearQ in Rovo Chat to start testing. BearQ instantly parses acceptance criteria, technical requirements, and comment threads to author test cases, document reproduction steps, and actively explore browser behavior. Whether Rovo leads initial triage or BearQ jumps straight into validation, quality assurance stays embedded directly in your flow of work – eliminating manual context gathering and costly handoffs.

Adapt tests as your application evolves

Fast-moving product teams shouldn’t be held back by static scripts. As features iterate and workflows shift, maintaining brittle test scripts becomes a full-time job.

Powered by real-time Jira context, BearQ autonomously explores and maps your application, discovering untested user paths and edge cases that scripted tests miss. Because it generates tests that dynamically adapt as application behavior changes, delivery teams can catch regressions before staging and move from planned changes to validated results in minutes rather than days.

Scale QA capacity without losing control

Expand your testing footprint without sacrificing trust or governance. BearQ acts as an autonomous teammate, exploring and validating across your application, while your team sets the guardrails, directs focus, and retains oversight where it matters most.

When BearQ finds regressions, UX issues, or data inconsistencies, it creates actionable Jira issues with reproduction steps and evidence. Less time spent triaging means faster feedback, quicker resolution, and more time for QA to focus on high-impact risk.

Availability

BearQ for Jira is available on the Atlassian Marketplace. Connect BearQ to your Jira workspace today to bring testing and delivery together into a unified, agent-orchestrated workflow.

What's changing

Branch restrictions now support adding the following to Write Access and Merge Access branch permissions in your branch restriction rules:

• Repository access tokens (RAT)
• Project access tokens (PAT)
• Workspace access tokens (WAT)
• Forge apps
• Rovo Dev

This applies to both repository and project-level branch restrictions.

What you need to do

No action is required. To use this feature, navigate to Repository settings → Branch restrictions or Project settings → Branch restrictions and add your access tokens, Forge apps or Rovo Dev to the desired permission rules.

For more information see our community post.

Bitbucket pull request (PR) update events for Forge apps now feature an additional changes field in their payloads. This field is present when a PR is updated due to a new commit being pushed to the source branch.

This update allows Forge apps to distinguish between code-level updates (new commits) and metadata updates (such as changes to the title or description). This is a backward-compatible change; no existing fields have been removed or renamed.

What you need to do

For most apps, no action is required. If your app is already listening to Bitbucket PR update events, the additional field will automatically be available in the event payload.

However, if you validate event payloads with a strict schema, ensure your validator is updated to allow the new changes property. You can review the updated payload structures in the Bitbucket pull request updated event reference documentation.

Here’s a stat that’s been rattling around in my head. In our 2026 AI SDLC study, 94% of engineering leaders told us they’re using AI, but only 6% have the systems to actually scale it across their whole software lifecycle. Almost everyone is playing with agents, yet almost no one can let agents run at scale without things breaking.

The gap between “cool demo” and “I trust this across hundreds of engineers” is exactly what we’re trying to close with the new features we are shipping today.

First problem: agents that don’t know anything about your world

Agents fail when they don’t understand your world: your architecture, your decisions, your standards, the institutional memory that lives in your team’s heads, documentation and communication channels.

We’re grounding agents in a shared context layer, with governance baked in, so the same system that gives agents context also controls what they can touch:

• Code Context, built on Atlassian’s Teamwork Graph, gives Rovo and coding agents secure intelligence across multi-repository codebases. This enables more accurate results across the entire lifecycle, from vetting backlog ideas for architectural feasibility and generating code-aware implementation plans to accelerating bug triage and root-cause discovery.
• Agent Context Controls let platform teams govern which agents can operate in a space and exactly what they’re allowed to see.

BETTER CONTEXT, BETTER OUTCOMES.

The payoff of better context is real. In a recent analysis by DX, teams whose AI tools used the most Atlassian Teamwork Graph context shipped roughly 64% more per developer.

Second problem: everything happens one prompt at a time

The next shift in the AI SDLC isn’t more terminal windows open on your second monitor. It’s governed agentic execution (aka, work that runs as an always-on loop instead of a one-off session). Here are new features coming soon to Jira to turn engineering backlogs into always-on, automated execution cycles:

• Agent loops in Jira automate the path from backlog to pull request by continuously scanning for well-defined, unassigned work items, delegating them to Jira Coding Agent for execution and testing, and opening ready-to-review PRs directly in Jira.
• Standards enables platform teams to define organizational coding standards once and map them to repositories, automatically sharing consistent quality guardrails across every agent and developer operating in the codebase.
• AI Review puts a dedicated agent on every pull request, checking it against those standards and flagging problems before they reach a human.

Put it together and the loop is: developers define intent and guardrails → agents execute in parallel → developers and PMs review and approve what actually ships → agent updates shared context based on completed work. You stay in control of the merge button but stop being the bottleneck for everything leading up to it.

Third problem: nobody can prove any of this is working

Measuring AI impact across an engineering org is hard. There’s no perfect playbook yet, but leaders still need a clear, grounded way to understand where AI is helping and where it isn’t. That’s why we built these accountability and visibility tools directly into the system:

• DX for Agentic Development measures AI impact across throughput, quality, adoption, and cost, mapping what you spend to what you ship. It unifies AI Code Insights, tool and MCP tracking, model-to-task fit, and academic-validated Agent Experience (AX) research with rich software context and guardrails, closing the loop between AI observability and governance.
• Jira Agent Usage Dashboard helps team leaders understand which agents are used in their workflows and improve team delivery velocity with agents.

This is what takes governed agent loops from an experiment to something you can put in front of your board.

Let the loop run for you

For the past couple of years, the story of AI in engineering was about individual magic moments. A slick autocomplete, a clever prompt, a demo that made everyone lean in. That’s great, but you can’t run an engineering org on moments.

Moving from ad hoc agent sessions to always-on workflows is how AI actually scales across an engineering org. Build on top of context so agents know what they’re doing, govern agentic execution so the work keeps moving, and measure so you can understand what’s working. That’s the whole game, and it’s what we’re shipping today.

I can’t wait to see what your teams build when the loop is running for you.

Join us on September 22, 2026 for the State of AI SDLC, a digital summit for engineering and product leaders exploring how AI is changing the way software gets planned, built, and run. Reserve your spot.

Availability: Code Context is gradually rolling out to paid Atlassian customers through open beta. Agent loops, Standards, and AI Review are available in private early access. Agent Context Controls and Agent Usage Dashboard will be generally available to paid Jira customers in the coming months. DX for Agentic Development will be generally available for Atlassian DX customers this quarter.

Bitbucket has added support for bearer authentication for API tokens.

What’s changing:

Bitbucket Cloud has added support for Bearer authentication when using API tokens. You can now authenticate your API requests by sending the token in a Bearer authorization header, providing a more standard and secure alternative to Basic authentication.

curl --request POST \
--url 'https://api.bitbucket.org/2.0/repositories/{workspace}/{repository}/commits' \
--header "Authorization: Bearer {api_token}" \
--header 'Accept: application/json'

What you need to do:

No action is required. Bitbucket Cloud continues to support both Basic and Bearer authentication for API tokens. If you have existing integrations using Basic authentication, they will continue to work without modification.

For more information on creating and using tokens, see the API tokens documentation.

The missing layer between what your team decides to build and how your agents execute it.

The bottleneck in AI-assisted development isn’t code generation. It’s intent.

When you leave details out, the model fills in the blanks for you. Omit the scope, architectural constraints, and edge cases, and the agent quickly starts solving a completely different problem. When that happens, the agent isn’t just wrong – it’s confidently wrong, moving just as fast in a direction you didn’t intend. You end up debugging intent as much as code, and paying for it in rework, tokens, and time.

In a recent Atlassian survey, 60% of engineering leaders said their teams are shifting toward spec-driven development. Yet, fewer than 15% have a structured framework to actually do it. Getting the work right means building a spec your team can actually review together, and an agent that can execute without guessing. That’s what Jira Planner does: it turns rough ideas into structured, agent-ready specs grounded in a semantic understanding of your codebase, standards, and decisions.

How it works

1. Start with an idea of goal, even a rough one. You don’t need a fully-formed spec. Jira Planner asks the right follow-up questions to help you clarify scope, constraints, and what success looks like.

2. Grounded in your real context. Jira Planner reads your code across multi-repo setups, and pulls in context from Teamwork Graph. Plans reflect your architecture, your ownership structure, and your previous decisions, not generic assumptions.

3. Get structured artifacts, not walls of text. Jira Planner generates editable Confluence Live Docs that live right where your team’s work already does, connected back to Jira. That means your team can start working in the plan right away, instead of moving it somewhere else first.

4. Plan as a team, not alone. Share the plan with engineers, PMs, and designers, so you can co-edit, leave inline comments, and work through trade-offs together. Alignment happens all while the the plan is still taking shape, not after it’s already final.

5. Check whether the plan is ready. Jira Planner surfaces ambiguity upfront and tells you whether your spec is detailed enough for execution, with specific suggestions for what’s missing.

6. From plan to work. Jira Planner breaks the finalized plan into Jira work items, sequenced with dependencies and milestones, with each one carrying its own acceptance criteria and the context of the full plan. From there, agent orchestration takes over, picking up exactly where planning left off.

For the people who define what gets built

Jira Planner is for tech leads, senior engineers, engineering managers, and PMs tackling the kind of work that requires alignment: multi-sprint features, architectural decisions, and anything where more than one person needs to agree on scope.

The plans it produces are grounded in your actual repos, your team’s context, and decisions already made elsewhere in the organization. That’s what turns a rough proposal into something a team can confidently hand off to agents to build.

Availability

Jira Planner is now available in Early Access for Jira Cloud customers with Rovo enabled and Teamwork Graph connected. You’ll also need Confluence connected, since Jira Planner publishes plans as Live Docs. We’re rolling out access in waves and looking for teams who want to shape what Planner becomes. Your feedback will directly influence what we build next.

Get early access

Join the waitlist →

The pain of building decks the old way

You know the drill when it comes to creating presentations. The afternoons spent creating a deck from scratch – aligning text boxes, copy and pasting images, moving the slides around to find the right flow, the list goes on and on. The problem isn’t that the story isn’t there. It’s that getting the story out onto slides takes way more time than it should.

That’s where Confluence slides comes in. It’s the fastest way to transform existing knowledge into a presentation-ready deck in seconds — no blank slide, no copy-paste, no app-switching. Simply describe what you want and watch Rovo generate context-rich presentations in real-time.

Creating a deck shouldn’t be hard. But for most teams, it is. The manual effort of building decks the old way is painful, and the numbers are hard to ignore:

• 37% of total time spent in PowerPoint goes to formatting — adjusting colors, fonts, and layouts instead of refining the actual message (Source: Nielsen)
• 42% of that time is wasted searching for the right templates, icons, or past slides (Source: Nielsen)
• Corporate professionals spend roughly 7 hours per week on slide tasks, costing an estimated $25,500 per year per employee in lost productivity (Source: Nielsen)

Teams don’t lack ideas or content. They lack a better, faster way to turn what they already know into a story they can easily share. The result is that every deck starts from scratch, even when the content already exists somewhere.

Say hello to Confluence Slides

With Confluence slides, teams now have a new way of creating slides with Rovo, slides that are context-rich and generated with AI in seconds. Rovo pulls context from across Atlassian and connected third-party apps like Slack and Google Drive to create impactful, visual presentations grounded in your team’s work. Simply ask Rovo to create or edit your slides and it’ll determine slides structure, create content, and even build visualizations like charts and graphs — all from a single prompt. You’ll be able to collaborate and present your slides directly in Confluence, without breaking the flow of work and having to switch apps.

A few ways teams can use Confluence slides:

• Project kickoffs — Generate a presentation-ready kickoff deck from your project brief, complete with visuals like a timeline chart to get stakeholders bought in from day one.
• Campaign analysis readouts — Turn campaign performance data and retrospective notes into a visual deck, with bar charts and funnel charts generated from data already in Atlassian.
• Customer pitches — Spin up a tailored customer pitch deck from existing account notes, case studies, and competitive intel in Confluence.

A closer look at Confluence slides

Your team’s knowledge already lives in Confluence — now it can be turned into a polished deck in seconds with Confluence slides. Start with a prompt, refine with Rovo, and present your new visual presentation with confidence, all without leaving Confluence.

Create from context, not from scratch

Today, your team’s knowledge is scattered across docs, projects, and meeting notes, so every deck starts from a blank slide. Figuring out what to include and how to structure the story takes as long as making the deck itself. Confluence slides fixes that.

• Powered by the Teamwork Graph: Rovo pulls context from across Atlassian and connected third-party sources like Slack, Google Docs, Microsoft Excel so your deck is grounded in real team knowledge.
• Narrative structure built for you: Rovo determines what to include, how to sequence it, and how to frame the story.
• No blank slate: Creation always starts from existing content or a simple prompt, so you’re never stuck staring at a blank slide.

From first draft to final story — fast

Getting from a first draft to something presentation-ready takes longer than it should — every small change means more manual work. Confluence slides keeps the momentum going, with Rovo doing the heavy lifting for you.

• Impactful visuals to tell your story: Automatically generates charts, timelines, bar graphs, and images directly within a slide — so your deck is polished and presentation-ready from the first draft.
• Rovo-powered editing: Use Rovo to make edits inline, such as restructuring, rewriting, or improving your slides.
• Quick manual edits: Put the finishing touches directly on the slide yourself, such as editing text or reorganizing slides from the filmstrip.

Collaborate and present, all in Confluence

When your deck lives in a different tool from your knowledge, things drift. Teams end up maintaining two separate artifacts — the doc in Confluence, the deck somewhere else — and it’s rarely clear which is current. With Confluence slides, that split disappears. Your slides live where your knowledge lives, so you can create, share, collaborate, and present your work in one place.

• Real-time collaboration: Invite teammates to collaborate on a deck, with inline comments to gather feedback and align stakeholders.
• Present directly from Confluence: Hit presentation mode and go — no exporting, no app-switching, no friction between finishing and presenting.
• Respects Confluence permissions: Slides live in the Confluence content tree, inheriting existing space and page permissions so access is always controlled.

Tips to get the most out of Confluence slides

Can’t wait to get started? Getting to a great deck is faster when you give Rovo the right starting point. Here are a few tips:

1. Provide your sources upfront
   Link to the exact pages, Jira projects, or 3rd party connector you want used. You can also have Rovo follow a specific slide template by linking to it.
   “Create slides based on [this project poster] and [this Q3 retro]. Use the data from the retro as the primary source. Use this deck as the template — match its slide layouts: [link].”

2. Set your brand colors
   Hex codes work best, but Rovo can also interpret color descriptions, vibes, or links to a company website.
   “Use our brand colors: 0052CC and FF5630.” / “Match the palette from atlassian.com — blues and neutrals.”

3. Define the narrative and structure
   Tell Rovo what to include, exclude, or reorder. If you have a story arc, spell it out.
   “Start with a bold problem statement; end with a clear call to action.” / “Include these slides in order: intro, problem, solution, timeline, budget, next steps.”

4. Specify audience and tone
   Say who it’s for and how it should sound.
   “C-suite budget review — concise, confident, data-driven. Max three bullets per slide.”

5. Control visuals
   Note preferences for imagery, icons, charts, or layout style.
   “Include a timeline graphic for the roadmap slide.”

Your next presentation is already in Confluence

The knowledge your team needs to build a great presentation already exists — in your Confluence pages, your meeting notes, your project plans. Confluence slides gives you a faster way to turn all of that into a story you can actually share, without spending the afternoon doing it manually.

No blank slate. No tool-switching. No reformatting. Just go from doc to deck in seconds, and present with confidence, all within Confluence.

If you’re already a Confluence user, create slides now.

Not yet using Confluence? Try it for free and discover how you can create and share knowledge across teams.

@MENTION AN AGENT ON ANY PAGE AND IT CREATES, EDITS, AND COMMENTS ALONGSIDE YOUR TEAM. THROUGH THE ATLASSIAN ROVO MCP, THE SAME AGENTS WORK FROM CLAUDE, CURSOR, OR YOUR IDE.

Agents have been working in Confluence since we launched custom agents in May 2024, and teams now run more than 5 million agent invocations a month. In February alone, Agents saved Atlassian customers more than 200,000 hours.

Now, agents can do practically everything you can do. Beyond creating or editing pages, Agents can comment, label, set status, and create whiteboards or databases — working exactly the way a teammate does. Mention one in the editor or a comment and it acts right there, grounded in your team’s own content. And through the Atlassian Rovo MCP, the same agents work from Claude, Cursor, ChatGPT, or your IDE, reading and writing the live page rather than a copy of it.

Getting work unstuck

Handing real work to an agent only matters if you can trust what it does. That belief shaped every decision we made bringing agents into Confluence, so before an agent ever touches a page, you know it will work within the permissions you set, act only where it should, and leave a clear trail behind it. With that foundation in place, agents become something you actually want on your team.

A page waits for someone to have time, feedback sits in comments until the owner circles back, and the decision everyone needs stays in one person’s head until they write it down. None of that is a hard problem. It’s that a person has to do every step, and people are busy.

Agents change the pace without changing the job. Give one a task and the page moves while you’re in a meeting. Routine feedback gets processed before you reopen it, and the decision that actually needs your judgment is waiting with the work around it already done.

How it works

• Mentioning an agent. Tag an agent in the editor or in a comment the same way you’d tag a colleague. It reads the page as context and responds there, contributing to the page without anyone moving the work or rebuilding the context.
• Seeing what agents actually did. Confluence Analytics counts agents alongside people across page, space, site, and Mission Control views. Switch any page between all viewers, people, and agents to see which agents read it and how often. Agents appear as contributors on content they helped create or update, and an agent working on someone’s behalf shows up next to the person who invoked it. If an agent read a page 200 times last week, you can now see that.
• Doing the work, not describing it. Agents create and edit pages, work with comments, apply labels, set status, and act across Confluence content types. A single prompt returns a complete formatted page with panels, tables, and diagrams, or chains a longer job end to end, like drafting release notes from a merged pull request, publishing them, and sharing a public link. The same capabilities are available through Rovo Chat, automations, custom agents, MCP, and the command line.
• Bringing your own agent. Create a Team agent in Confluence, start from a ready-made template, or connect a custom or external agent through MCP. Wherever the agent comes from, it works with the same core Confluence actions.
• Working from your tool of choice. Through the Atlassian Rovo MCP, agents in Claude, Cursor, ChatGPT, or your IDE read and write live Confluence content. The agent reads what is true right now and writes back to the same page your team is looking at.
• Setting the rules for a space. Space-level instructions give agents a shared playbook for how that team works, so the same agent behaves differently in a marketing space than in an engineering one. Agents never surface content the person who invoked them couldn’t already see, every action is reversible in version history, and a stale edit is rejected rather than quietly overwriting a teammate.

What teams are already building

The agents customers built before this release are a good preview of what a more capable one can do. Riverty’s Lessons Learned agent mines past work so teams stop re-learning the hard way. KFC’s Architecture Review agent pre-checks proposals against document standards. Pythian’s Progress Tracker pulls signal from Jira and Confluence and drafts the status email. Sprout Social’s Onboarding agent answers roughly 80% of new-hire questions and spins up role guides.

You don’t need to code anything to build one. If you can describe what you want in plain English, you can build an agent in Rovo Studio and publish it to your team.

Better context = better output

Agents in Confluence run on the Teamwork Graph, the living context layer that connects work, people, knowledge, and code across Atlassian and your connected tools. In our own benchmarking, agents grounded in Teamwork Graph context returned 44% more accurate results while using 48% fewer tokens.

Availability

Agentic workflows in Confluence are powered by Rovo, available on Standard, Premium, and Enterprise Cloud plans. All Atlassian Cloud customers can use the Atlassian Rovo MCP Server.

Getting started

1. Open a Confluence page and @mention an agent in a comment.
2. Browse ready-made agent templates and start from one built for your team’s job.
3. To work from another tool, add the Atlassian Rovo MCP server to your AI client:

• Explore agent use cases
• Set up the Rovo MCP server
• Learn from more examples of customer agents

Today we’re rolling out seven new AI features across Trello for every paid user on a Standard, Premium, or Enterprise plan. Individually, each one erases a small, familiar chore. Together, they answer a bigger question we’ve been sitting with for a long time: what if the busywork mostly handled itself, so you could focus on the work that actually matters to you?

Keep the boards, lists, and cards you love. Outsource the rest to AI.

SEVEN WAYS TO SUPERCHARGE YOUR TRELLO WITH AI

1. Create a board with AI

Leave the blank board behind. Describe a goal, whether it’s planning an offsite, running your first 5K race, or figuring out your meal planning for the week and Trello builds a structured, ready-to-use board in seconds, complete with lists and cards. A template is generic and waits for you to customize it. A board built with AI starts personalized. Every board defaults to private, so it’s yours to edit before anyone else sees it.

This is the one that changes how it feels to start something. The hardest part of any project is the first move; now the first move is a prompt.

1. Merge multiple cards into one

A frequently asked for feature is finally here! Have two cards saying the same thing? Drag one onto the other and they become one. Trello blends the title, description, and details, carries over links, attachments, custom fields, and labels, and keeps the original context below a divider so you never lose it. The earliest due date wins; to-dos become a checklist. Don’t like the result? Undo it. The originals are archived, not deleted.

Duplicate cards are how boards quietly rot. This keeps them clean without the manual reconciliation nobody has time for.

1. AI-generated checklists

One click turns a card into a plan. Trello reads the title and description and suggests a checklist of the steps to get it done. Name the checklist to steer the result, then edit, reorder, or regenerate. It’s fully editable, exactly like one you’d type yourself, only you didn’t have to type it.

1. AI-recommended focus time

A task on a board isn’t done until it has a place in your day. Connect a calendar, open any card, and Trello finds open time and recommends a focus block for it. Accept, dismiss, or set natural-language rules for when and what it suggests. Turn on proactive scheduling and Trello checks daily for cards due in the next five days and blocks the time for you. It can view your calendar to suggest, never change it without your say-so.

This is where a board stops being a to-do list and starts being a plan for actually getting it done.

1. AI-generated images for backgrounds and covers

Stop scrolling for the perfect image. Describe it and Trello makes it. Change a board background or add a card cover in seconds. Small thing? Maybe. But a board you’re proud to look at is a board you come back to, and coming back is the whole game.

1. Set a due date from the card title

Type “Submit report by Friday” and Friday becomes the due date. Trello reads relative dates (“tomorrow”), specific ones (“December 1”), and weekday references (“this Thursday”) the moment you create a card. You were always going to set that date, now you don’t have to think about it.

1. [Coming Soon to Trello Labs] AI-generated widget cards

An entirely new kind of card, live in Trello Labs later this month. Type /widget and give it a prompt (“daily AI news headlines,” “an inspirational quote at the top of my To Do list,” “the US Open schedule”) and Trello builds a richly formatted card that shows information at a glance. It’s where we’re headed: a board that doesn’t just hold your work, but brings the world into it.

GET STARTED

If you’re on a paid plan these new features are waiting for you now. Hit Create and describe a board. Drag one card onto another. Type a due date into a title and watch it move. Not on a paid plan yet? Start a 14-day Premium free trial or upgrade to turn them on.

We built these tools because sometimes you’d rather not think about building or managing a board very closely. Go make something, and tell us what you want next!

As announced in 05 Feb 2026, we have removed the Bitbucket Cloud Connect addon linker APIs. These endpoints are no longer available.

What’s changing

The following REST API endpoints have been removed from Bitbucket Cloud:

• GET /2.0/addon/linkers
• GET /2.0/addon/linkers/{linker_key}
• GET /2.0/addon/linkers/{linker_key}/values
• PUT /2.0/addon/linkers/{linker_key}/values
• POST /2.0/addon/linkers/{linker_key}/values
• DEL /2.0/addon/linkers/{linker_key}/values
• GET /2.0/addon/linkers/{linker_key}/values/{value_id}

What you need to do

If you were using these endpoints, you must update your integrations to remove these calls as they will now return an error. For more information on the end of support for Connect on Bitbucket Cloud, please refer to the official announcement.

We’ve added new navigation targets for the Forge bridge’s router object. These allow you to use the router API to navigate to supported UI module pages in Bitbucket.

What’s changing

The following Bitbucket modules are now supported as navigation targets:

• bitbucket:workspaceGlobalPage
• bitbucket:workspacePersonalSettingsPage
• bitbucket:workspaceSettingsMenuPage
• bitbucket:projectSettingsMenuPage
• bitbucket:repoMainMenuPage
• bitbucket:repoSettingsMenuPage

What you need to do

You can now update your Custom UI or UI Kit apps to use these targets with router methods. For implementation details and examples, see the router object documentation.