AI-Native Software Development Capabilities in Jira

Sep 2026A simpler way to run AI agents in Bitbucket PipelinesThis post introduces two key enhancements to Bitbucket Pipelines for AI agent execution: 1. Workspace-level enablement of built-in AI agents (Pipelines troubleshooter, Flaky test fixer) via Workspace settings, abstracting away repository-specific configuration. 2. Reusable step configurations that allow teams to define common runtime settings (image, size, etc.) once and apply them to multiple Pipeline steps, reducing YAML duplication. These features simplify the setup and management of AI agents within Bitbucket Pipelines.

Sep 2026We’re bringing governed agent loops to the AI-Native SDLCIntroduces Code Context built on the Teamwork Graph for secure, multi-repository intelligence, enabling agents to understand architecture, decisions, and institutional memory. Also introduces Agent Context Controls for platform teams to govern agent access and permissions. Details agent loops in Jira for automating the path from backlog to pull request, including scanning for work, delegating to Jira Coding Agent, and opening PRs. Introduces 'Standards' for defining and mapping organizational coding standards to repositories, and 'AI Review' for automated PR checks against these standards. Introduces 'DX for Agentic Development' for measuring AI impact across throughput, quality, adoption, and cost, and the 'Jira Agent Usage Dashboard' for team leaders to track agent usage and velocity.

Aug 2026How we made vulnerability fixes review-ready with Agentic PipelinesThis post details the implementation of agentic pipelines for automating routine vulnerability fixes in Bitbucket Cloud. It describes a workflow involving Jira Automation, a custom dispatcher and closer, Bitbucket Agentic Pipelines, Rovo Dev, and Atlassian Model Context Protocol (MCP) tools. The agentic pipeline checks for eligible tickets, groups related work, updates repositories, runs build and test suites, and opens pull requests. A 'closer' component verifies deployed fixes and updates Jira tickets. Key learnings include making instructions specific to the codebase, keeping verification deterministic and human-controlled, failing safely, and keeping access narrow and attributable. The post also introduces the beta availability of Bitbucket Agentic Pipelines.

Aug 2026Agentic automation in practice: putting standard engineering work on autopilotThis post details the implementation of an agentic automation system for security vulnerabilities. It introduces Bitbucket Agentic Pipelines, Rovo Dev, and Atlassian MCP tools to create a three-part system: a dispatcher that finds and classifies eligible work items, a coding agent that applies fixes using codebase-specific skills, and a closer that verifies deployments and transitions tickets. Key technical contributions include defining agents as versioned pipeline steps, using .rovodev prompts and skills to encode institutional knowledge, and implementing idempotent workflows for reliable re-runs. The system achieved a 95% first-run merge rate for automated vulnerability fixes.

Aug 2026Opening the door to agent autonomy: The architecture behind Rovo’s agent harnessThis post introduces the architecture of Rovo's new agent harness, detailing its split-plane design (data and control planes), isolated compute sandboxes, asynchronous multi-agent coordination via interactive sub-agents, and error recovery mechanisms (discovery probes, checkpointing). It also covers programmatic tool calling, dynamic model selection, dynamic/static tool loading, and a callback bridge for secure tool invocation. The system is integrated with an automated evaluation pipeline for continuous improvement.

Aug 2026From prototype to production: lessons learned taking AI-built software to enterprise scaleThis post details the evolution of an AI-driven software development process from a prototype to an enterprise-grade product. It describes the initial multi-agent orchestration for building a prototype, including a planner, coder, and reviewer agent, and the subsequent challenges encountered during production deployment, such as schema differences and lack of architectural guidance. The team iterated by adopting a 'build one feature end-to-end' approach, followed by a more robust 'understand and plan first, then execute' methodology. This involved developing an interactive planner and a PR review buddy to address gaps in domain understanding and improve review efficiency. The post quantifies a 5x output gain compared to traditional builds and outlines key lessons learned, including the importance of human ownership of domain and decisions, treating agents as teammates, and the value of upfront planning and custom tooling.

Aug 2026Rovo for Microsoft 365: Turn conversations into Jira workThis post announces the integration of Atlassian Rovo as an agent within Microsoft 365 Copilot and Teams. It highlights how Rovo leverages the Teamwork Graph to bring context from Jira, Confluence, and other Atlassian products into Microsoft 365. The Jira Cloud for Microsoft Teams app is updated to understand natural language commands powered by Rovo, allowing users to create, update, and assign Jira work items directly from Teams conversations. This includes scenarios like moving Jira tickets, assigning tasks to AI agents, and creating new work items with context pre-filled from the conversation thread. The integration aims to streamline workflows by connecting conversational platforms with work tracking systems.

Aug 2026Jira goes where spreadsheets can’tThis post details the technical implementation of new Jira features: Capacity view for individual capacity planning, formula fields for custom calculations on work items, and space insights for live, custom dashboards. It highlights the integration with Rovo for natural language interaction, enabling users to create, update, and analyze plans, budgets, and reports. The Capacity view allows planning in hours, percentages, or days, accounting for leave and operational work. Formula fields support calculations like budget variance and ROI, and can trigger automations. Space insights allow dashboard creation via natural language and provide AI-driven explanations of trends. The post also mentions the ability to import spreadsheets into capacity plans and the refresh of the List view for improved inline editing and filtering.

Aug 2026Introducing Jira PlannerThis post introduces Jira Planner, a new capability within the Atlassian Rovo MCP Server platform. Jira Planner focuses on transforming rough ideas into structured, agent-ready specifications. It achieves this by asking clarifying questions to define scope, constraints, and success criteria. It grounds plans in the user's real context by reading code across multi-repo setups and pulling in context from Teamwork Graph, reflecting architecture, ownership, and previous decisions. The output is editable Confluence Live Docs, facilitating team co-editing and inline comments. Jira Planner also surfaces ambiguity and provides suggestions for missing details to ensure specs are ready for execution. Finally, it breaks down finalized plans into Jira work items, sequenced with dependencies and milestones, enabling agent orchestration.

Aug 2026Create AI-generated slides in seconds | Atlassian ConfluenceThis post introduces Confluence Slides, a new capability powered by Rovo AI that transforms existing Confluence knowledge into presentation-ready decks in seconds. It highlights the pain points of traditional slide creation, emphasizing the time spent on formatting and searching for assets. Confluence Slides leverages the Teamwork Graph to pull context from various sources, automatically structures narratives, generates impactful visuals like charts and timelines, and allows for inline editing and collaboration within Confluence. It also provides tips for optimizing AI-generated content by specifying sources, brand colors, narrative structure, audience, tone, and visual preferences.

Aug 2026Introducing the AI context engine for your entire codebaseThis post introduces 'Code Context' as a new capability within the Atlassian Teamwork Graph. Code Context indexes codebases from Bitbucket and GitHub repositories, making them accessible to AI agents and developers. It combines lexical and semantic search to retrieve relevant source code and connects it to other organizational signals like Jira work items and Confluence pages. The goal is to provide AI agents with comprehensive context to improve output accuracy and reduce token usage. It respects existing SCM permissions and is available in early access.

Aug 2026Agents are in Confluence (and wherever you need them to be)This post announces the expansion of agent capabilities within Confluence, allowing them to perform actions previously only possible by human teammates, such as commenting, labeling, setting status, and creating whiteboards or databases. Agents can now operate directly within the editor or comments, grounded in the team's own content. The Atlassian Rovo MCP enables these agents to work from various external tools like Claude, Cursor, and ChatGPT, reading and writing live Confluence content. Confluence Analytics now tracks agent activity alongside human contributors. Space-level instructions provide agents with team-specific playbooks, ensuring behavior aligns with team workflows and adhering to permissions and action reversibility. Agents are available on Standard, Premium, and Enterprise Cloud plans.

Aug 2026What High-Throughput Engineers do Differently and Why AI Widens the GapThis post identifies and elaborates on six fundamental engineering practices that high-throughput engineers leverage, which are significantly amplified by AI: 1. Small, single-responsibility PRs: AI makes managing many small PRs more feasible and reliable. 2. Spec-driven development: AI agents use detailed specs (work items, acceptance criteria) as context for execution, echoing graph engineering principles. 3. Fast, trustworthy dev loop: High test coverage and fast builds provide the spec for agents and enable autonomous testing/fixing. 4. Bounded parallelism: Engineers limit active human contexts to 2-4 high-cognition tasks, offloading routine work to agents. 5. Warm contexts: Providing options for cheap and fast context switching (multiple git worktrees, remote dev environments) is crucial as agents generate more work. 6. Fast review: Reciprocal reviewer networks and AI-assisted review (where compliant) become critical bottlenecks as code generation speeds up. Leaders should invest in review capacity, fast feedback loops, structured work, parallel environment options, and sustainability.

Aug 2026Why better tickets help agents write better codeThis post details how a team used AI agents and well-scoped Jira tickets to achieve a 5x increase in per-engineer output (lines of code, complexity, schema size, integrations) and a significant improvement in ticket quality (4.47/5 average score, 83% agent-ready). It emphasizes the value of detailed, executable tickets with clear acceptance criteria and context for agent execution, contrasting this with traditionally authored tickets. The post also identifies a gap in capturing emergent issues surfaced by agents during development and proposes making agent activity a first-class citizen on tickets as a solution.

Aug 2026How to Speed Up Connect to Forge Migration With AIThis post details how the authors used AI tools to accelerate the migration of five Atlassian Marketplace apps from Connect to Forge. After manually migrating the first app and establishing migration patterns, they leveraged AI for tasks such as reworking React frontends, mapping permissions, deploying code, checking logs, building Storybook components, and performing smoke testing. Key strategies for success included documenting patterns in the repository, feeding AI current Forge documentation and using the Forge MCP, planning before execution, creating small and reviewable code diffs, and instructing AI to use only Forge UI components. The authors emphasize that AI is best suited for replicating established patterns and repetitive work, while genuinely new problems should be handled by human engineers.

Aug 2026Coding at the speed of thought: how I talk to Rovo Dev from SlackThis post details the creation of a Python bridge that connects the Rovo Dev CLI's `acli rovodev serve` HTTP API to Slack via Slack Bolt and Socket Mode. The bridge allows users to interact with Rovo Dev from Slack without using a terminal. Key technical details include the use of `acli rovodev serve PORT --disable-session-token` to expose `/v3/set_chat_message` and `/v3/stream_chat` endpoints, the implementation of a security measure to only process messages from a specific user ID, and the use of systemd for process management. Future work includes streaming replies, multi-session support, slash commands, and file uploads.

Aug 2026How We Used Agentic Pipelines to Swarm DocumentationThis post details the implementation of agentic pipelines within Bitbucket Pipelines to automate documentation updates. It describes the creation of focused agents with prompts to update specific documentation types (release notes, quickstarts, API docs, changelogs) based on code changes detected by path-based conditions. A bootstrap agent is also introduced, which generates the necessary scaffolding (prompts, agent definitions, pipeline steps) for new documentation areas. The workflow involves developers reviewing and approving agent-generated pull requests. The post highlights the benefits of reduced developer time (1.5 developer-days/week), improved context switching, and documentation that moves with code. Key learnings include keeping jobs narrow, precise triggering, and making review the default.

Aug 2026Rovo Search: Why Rovo is a Leading Enterprise AI Search ToolThis post details significant enhancements to Rovo Search, focusing on its capabilities as an enterprise AI search tool. Key technical advancements include: 1. AI-generated answers with citations, synthesizing context from multiple sources. 2. Intent-aware routing in Jira, distinguishing between known-item lookup and knowledge-seeking queries. 3. Expanded connector ecosystem (50+ tools) for cross-tool search, respecting enterprise permissions. 4. Richer, more visual search results with interactive components and contextual information. 5. Deeper integration into Atlassian workflows (Jira, Confluence, link insertion) moving search from a destination to an embedded capability. Performance improvements include a 60% speed increase over the past six months.

Jul 2026Forge LLMs API is now GA: Here’s how you can build AI-native apps on AtlassianThis post announces the General Availability (GA) of the Forge LLMs API, which integrates Amazon Bedrock's Claude models (Sonnet, Opus) into the Forge platform. It highlights the benefits of keeping data within the Atlassian trust boundary, simplifying AI infrastructure management for developers, and enabling AI-native app development. The post showcases early adoption with over 100 apps in production and provides examples of Marketplace apps leveraging this capability for various use cases like workflow automation and content quality. It also mentions the ongoing investment in AI building blocks, including custom Rovo agents and skills.

Jul 2026From prompts to orchestration: Scale AI coding agent impact with Jira AutomationThis post introduces the expansion of Jira Automation to serve as an open control plane for AI coding agents, integrating native action steps for GitHub Copilot, Cursor, and Claude. It details how automation rules can be configured with triggers, conditions, and actions to package structured context, invoke agents with custom prompts, and log outcomes. The post provides three concrete examples of agentic automations: automated vulnerability patching, stale feature flag cleanup, and continuous bug triage, highlighting how these loops can reduce response times and technical debt.

Jul 2026Meet the new Rovo Chat: One prompt, multiple steps, zero hand-holdingThis post details the transition from a multi-agent routing system to a single-model reasoning engine ('Long Horizon') for Rovo Chat. The new engine uses a single model to hold full context across tools, enabling iterative reasoning (think, call tools, observe, reflect, repeat) up to 150 times per query. It employs adaptive reasoning effort based on query complexity. A tradeoff of increased latency for complex queries is mitigated by exposing reasoning traces. Offline evaluations show an 8.5% improvement in answer quality, a 23% improvement on Confluence tasks, and a 37% reduction in perceived latency due to real-time progress visibility. New capabilities include agentic tool use for cross-product workflows and long-running background tasks. The underlying stack is upgraded with Claude Opus 4.x class models and improved Teamwork Graph connectors.

Jul 2026Inside AI Builders Week: How teams work in the AI eraThis post describes the outcomes of Atlassian's AI Builders Week, focusing on the shift from individual AI workflows to team-level AI workflow redesign. It highlights specific examples of AI agents and tools built during the week, such as agents that monitor Jira for plan divergence, AI-powered review of strategy documents, agents that process customer requests from Jira into structured work items and draft PRs, and AI feedback skills that distill customer feedback into digests and update Jira Product Discovery. It also mentions initiatives to shorten the distance between R&D crafts by converting Figma designs to code and generating components from screenshots.

Jul 2026Give AI agents the full picture with Loom video promptsLoom introduces a new capability for generating structured action plans for AI agents directly from screen recordings. This feature captures visual context, narration, clicks, and visited URLs to create deterministic instructions, reducing the need for manual prompt engineering. The output can be shared with agents or converted into Jira work items.

Jul 2026How Axel Springer is using Rovo Dev to help engineering teams focus on higher-value workAxel Springer's pilot with Rovo Dev demonstrates practical applications of AI agents in software development workflows. Key contributions include: 1. Automated documentation generation (technical markdown and Confluence pages) triggered by code merges, directly from code diffs. 2. Proactive security vulnerability remediation by analyzing scan results (Snyk, Wiz), drafting fixes, and opening pull requests. 3. Context-aware branch creation and implementation planning by integrating Jira tickets, Confluence pages, and Compass service ownership. 4. Automated sprint summary generation by analyzing tickets and pull requests. 5. Generation of pull request descriptions based on code diffs and team standards. 6. Real-time updates to Compass service maps via code merges. The post emphasizes the importance of context and concrete use cases over abstract AI capabilities.

Jul 2026From tool to teammate: How one Atlassian team made AI a real coworkerThis post details the Atlassian People Insights (PI) team's transition from treating AI as a productivity add-on to fully agentifying their operations. They built a three-layer AI system (Foundation, Team, Individual) using VS Code, Rovo Dev, and Bitbucket, integrating with enterprise tools via MCP integrations and the DS Agent Starter Kit. This system provides persistent, structured access to context, enabling AI agents to act as collaborators. The post highlights the importance of context engineering, the role of peer champions in adoption, and the significant increase in AI usage and understanding within the team. It also mentions the upcoming Rovo CLI to reduce setup complexity and the use of the Teamwork Graph for context engineering.

Jul 2026Every agent. Every state. Full visibility in Jira.This post introduces the 'My agent sessions' feature within the Jira For You page, providing a consolidated view of agent lifecycle states (needs input, actively working, finished). It enables users to start agent sessions directly from the Jira home page, receive notifications for agent input requirements, and review/act on agent outputs within the work item panel without leaving the current view. This aims to improve the validation of agent output at scale by surfacing attention-needed items.

Jul 2026Introducing new MCP capabilities that turn context into actionThis post details new capabilities for the Atlassian Rovo MCP, enabling coding agents to perform expanded Jira actions. These include creating work items, attaching files (coming soon), finding assignees (v2 public preview), and editing comments directly from agent interactions. It also highlights the ability for agents to read Jira development panel information (linked branches, PRs, commits), connect product discovery ideas to delivery work, capture and update time logs, and retrieve context with fewer tokens through smarter response shaping. The post also mentions the Teamwork Graph CLI as an alternative for terminal access to context and tools.

Jun 2026Fix Bugs Faster with Atlassian Rovo MCPThis post details a workflow demonstrating how Rovo MCP, integrated with an AI coding tool (Cursor), enables an end-to-end bug-fixing process within a single working session. The workflow includes creating a Jira ticket from the IDE, fixing the bug in the local codebase, redeploying the application, validating the fix, and updating the Jira ticket, all without leaving the IDE. This significantly reduces context switching and friction associated with traditional bug-fixing processes.

Jun 2026How We Brought Enterprise-Managed Authorization to Rovo MCP with XAA and ID-JAGIntroduced Enterprise-Managed Authorization for Rovo MCP server using Cross-App Access (XAA) and Identity Assertion JWT Authorization Grant (ID-JAG). This allows enterprise IdPs to centrally authorize MCP access for approved clients, enabling seamless user onboarding without individual OAuth consent screens. The implementation involved validating ID-JAGs, resolving users across trust domains, and integrating with Atlassian OAuth to mint scoped access tokens.

Jun 2026Agentic Pipelines now supports OpenAI CodexThis post introduces OpenAI Codex as a new agent provider for Bitbucket Pipelines' Agentic Pipelines feature. It details how to configure Codex in `bitbucket-pipelines.yml` using `provider: codex` and mentions support for `codex-config-overrides.toml` for advanced configuration. It provides several sample use cases for Codex agents within pipelines, including auto-fixing failing builds, patching security vulnerabilities, syncing documentation, cleaning up feature flags, and triaging/labeling PRs. The post also frames Bitbucket Pipelines as an orchestration layer for agentic work in the SDLC, highlighting triggers, context, policy, and agent choice.

Jun 2026Spec-driven AI Migration: How Nearly 2 Quarters of Work Was Completed in One WeekThis post details a 'spec-driven AI migration' approach where Jira tickets are used as structured behavioral specifications for AI agents. The authors migrated over 100 GraphQL fetchers by defining detailed specs in Jira, which AI agents then used to generate migration code. Key contributions include: 1. Using Jira as a persistent, reviewable 'store of truth' for AI agent context, preventing context degradation across sessions or agents. 2. Shifting engineering focus from writing repetitive code to defining behavior, shaping context, and managing confidence. 3. Implementing layered verification: agent acceptance criteria, pre-review validation agents, and live traffic shadow testing. 4. Highlighting Jira tickets as a durable, structured prompt for agentic workflows, enabling parallelism and scalability.

Jun 2026Introducing @Jira: create work items from any Slack conversationThis post introduces AI-powered quick actions via `@Jira` mentions in the Jira Cloud for Slack app, enabling natural language work item creation and updates from any Slack channel. It allows direct work item assignment to teammates or AI agents, automatically populating fields by reading thread context. Users can configure default spaces and custom instructions per channel. Future integration with Atlassian's Teamwork Graph will enable more intelligent routing and expert identification.

Jun 2026Why AI Agents Drift Mid-Task and How a Multi-Agent System Fixes ItThis post introduces a multi-agent system architecture for AI agents to prevent task drift. It details the problem of context window limitations and proposes a solution where complex tasks are broken down into specialized agents (Code Cartographer, Engineering Alchemist, Visual Stylist, Ticket Auditor, Review Agents). The core innovation is anchoring these agents to Jira, using issue links as a dependency DAG and work items as prompts. A deterministic daemon orchestrates agent execution based on Jira ticket status, ensuring reliable scheduling and state management, which is contrasted with less stable local markdown file approaches. The post outlines a four-step process for building such a system: anchoring to Jira, running a watching daemon, giving agents personas, and reporting back to advance the loop.

Jun 2026Long Horizon: How Atlassian Built a Reasoning Engine for Complex AI TasksThis post introduces the 'Long Horizon' architecture for Atlassian's Rovo AI, replacing the previous hierarchical multi-agent orchestrator. Key technical changes include: a single LLM and context for complex tasks, adaptive reasoning depth based on query complexity, a flattened tool architecture where all product capabilities are exposed as uniformly named actions (e.g., jira__search_issues), and progressive disclosure of tool schemas via meta-tools ({product}__get_tool_schema, {product}__invoke_tool) to manage cost and accuracy. It also details context window management through a Context Compaction Service and task decomposition via child instances for wide tasks. The previous architecture's limitations in iteration depth, context sharing, and model adaptation are addressed by this new design.

Jun 2026Deeplink to your AI coding tool from JiraIntroduces deep linking from Jira work items to local AI coding tools, enabling direct invocation of agents like Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Rovo Dev CLI, and VS Code. The feature pre-fills prompts with work item context (summary, description, linked docs) via Atlassian MCP, reducing manual prompt crafting and copy-pasting. For desktop apps, the tool opens directly; for terminal tools, a modal provides a one-click copy action. MCP also allows agents to pull additional context during their work.

Jun 2026Atlassian's DESIGN.md is here: what we learned testing portable design context in practiceThis post evaluates the DESIGN.md format as a portable design context for AI agents. It compares its performance against Atlassian's existing MCP server and AI skills, highlighting trade-offs in token usage, response time, and context sophistication. Key limitations identified for DESIGN.md include its all-at-once context delivery, the necessity of shortening the file at the cost of detail, and its tendency to prompt agents to re-implement components rather than use existing libraries. The post suggests that while DESIGN.md is useful for prototyping, Atlassian's integrated systems offer better abstraction and efficiency for production environments.

Jun 2026Architecting Scalable ML Platforms: The Integrated Infrastructure and Acceleration Behind RovoThis post introduces ML Studio, Atlassian's enterprise-scale ML development platform, detailing its architecture and design principles for scalable, high-velocity, and governed ML systems. It highlights key capabilities such as reusable ML modules (versioned, sharable components with Git integration and automated CI/CD), a unified workflow orchestrator (CLI/portal for scheduling, composable workflows, hot clusters), and embedded compliance controls (user identity, domain-level, and column-level data access enforcement with tag propagation and default safety). The post also details improvements in developer productivity through automatic caching (saving 1000+ hours/month), experimental workflows (accounting for over half of ML Studio runs, saving 100+ hours/day), and easy cross-functional integrations with experiment tracking, feature stores, model registries, monitoring (ML Lens), and deployment platforms. Common workloads powered by ML Studio include GenAI, Predictive AI, and Training & Evaluation. AI features empowered include Rovo Search, Dev-AI, AIOps, Knowledge discovery, Confluence AI, and Loom AI/CoreML.

Jun 2026Improving Code Reviewer with Atlassian PR ContextThis post details the integration of similar past PR context (both diff and comments) into the Rovo Dev Code Reviewer. Experiments showed that combining diff and comment context significantly improved precision and recall, with precisionPerfect reaching statistical significance. A deliberate design decision was made to restrict context retrieval to the same repository due to quality trade-offs with cross-repo context. Online experiments demonstrated a lift in resolution rate (from 31.92% to 41.90% externally) and increased engineer feedback. Case studies illustrate how this context helps with type signature correctness and understanding team framework patterns and culture. The post also highlights efficiency gains, with fewer LLM requests and function calls despite increased input tokens.

Jun 2026Build AI-powered Forge apps with Atlassian-hosted LLMsIntroduces the Forge LLMs API, a new capability allowing developers to directly call Claude models hosted within Atlassian's secure environment. This eliminates the need for external model integration or infrastructure management, ensuring data stays on-platform and enabling apps to qualify for the 'Runs on Atlassian' badge. The API supports chat and streaming interactions, with model selection (Haiku, Sonnet, Opus) to balance cost, latency, and capability. Pricing is usage-based, measured in credits per input and output token. Examples provided include Confluence AI assistants, LLM web triggers, and agentic LLM web triggers.

Jun 2026How We Cut up to 80% of Engineering “Chores” Using AI Agents in JiraThis post details the practical application of AI agents within Jira for automating engineering chores. It describes how structured Jira work items, combined with reusable agent skills and explicit instructions, are used to delegate tasks like fixing flaky tests and cleaning up stale feature flags. For flaky tests, it outlines specialized agent skills (unit, integration, visual regression) and reproduction instructions. For feature flag cleanup, it explains how cron jobs create Jira tickets with flag context, and how agents use repository-specific skills or a fallback generic skill to generate pull requests. The human-in-the-loop aspect is emphasized, with engineers reviewing and merging agent-generated code.

Jun 2026How Content Assistant raised the design quality bar without slowing us downThis post details the development and impact of the Content Assistant, an AI agent built on Atlassian's Rovo platform. It describes how the agent drafts UX copy, surfaces content standards, and integrates with existing workflows (Slack, Confluence, Jira). The post highlights the agent's success in improving content quality and governance, not just speed. It outlines the 'AI-native content system' architecture with four layers: context stores, agents and workflows, an operating model with trust tiers, and governance/feedback loops. The post emphasizes the importance of structured context stores for LLMs and feedback loops for continuous improvement. It also mentions the use of Rovo's capabilities for Jira actions and the integration with other Atlassian apps.

May 2026From Ambiguous Questions to Action: Research Mode in Rovo Dev CLIIntroduces 'Research Mode' to Rovo Dev CLI, a structured workflow for investigating ambiguous questions before taking action. This mode breaks down questions into research domains, uses top-down (permissions-based) and bottom-up (code/Jira/Confluence) search strategies, delegates to focused subagents, and synthesizes findings into a report with references and next-step options (Jira tasks, Confluence pages). It emphasizes discovery as a first-class workflow, the importance of search direction, clear domain boundaries for subagents, multi-round research needs, and the value of a structured final artifact.

May 2026Agentic Pipelines now supports Claude CodeThis post announces the integration of Claude Code as a provider for Agentic Pipelines, allowing teams to use Claude for AI-driven automation within Bitbucket Pipelines. It details how to configure Claude as a provider and provides a deep dive into the 'fix-flaky-test' agent, explaining its functionality, how it works, and how to set it up. It also mentions the use of context variables for custom agents and the future support for more third-party CLIs.

May 2026Accelerated frontend development with RovoDev in a practical exampleThis post details the practical application of Rovo Dev, an AI-assisted coding tool, in accelerating the development of a public version of Atlassian's App Updates feature. It highlights a 3.5x speed improvement compared to manual estimates, achieved by two part-time frontend and two part-time backend engineers in 14 working days for the core frontend. Key technical contributions include the use of a 'repository index' for efficient AI pattern matching, a 'project knowledge wiki' for deep codebase context, and a 'memory system' for continuous AI improvement. The post also emphasizes the role of Jira tickets as tasks and audit logs, and the importance of various testing stages (unit, integration, VR, E2E, mutation testing) as 'eyes' for AI code quality validation. Practical tips for effective AI usage are provided, including prompt engineering, context optimization via skills, and script generation for repeated tasks.

May 2026Rovo Dev in Jira as my Spec Driven executorThis post details a personal workflow for spec-driven development using Atlassian's Rovo Dev CLI and Jira. It outlines a process where AI assists in understanding issues, drafting technical plans, and generating detailed specifications. The author emphasizes a human-in-the-loop approach for complex tasks, involving interactive review and refinement of AI-generated plans and code. The post highlights the benefits of this approach for code quality, maintainability, and developer productivity, contrasting it with 'vibe-coding' and emphasizing the importance of context and existing codebase patterns for AI-generated code.

May 2026How customers are using Confluence Agents to turn knowledge into actionThis post details how customers are using Confluence Agents (powered by Rovo) to automate workflows, specifically focusing on turning knowledge into action. It provides seven customer examples (HarperCollins, Docusign, Riverty, KFC, Pythian, Sprout Social, Procore) demonstrating agent capabilities in Confluence and Jira for tasks like meeting summarization, PRD authoring, lessons learned extraction, architecture review, progress tracking, onboarding, and backlog synthesis. It highlights the Model Context Protocol (MCP) for integrating with third-party tools (Lovable, Replit, Gamma) and introduces Rovo Studio for building custom agents with plain English instructions, tool selection, and knowledge scoping. Automation workflows are also discussed, with an example of a 'Feedback to PRD & Spec Author' agent triggered weekly to analyze customer feedback and generate PRD drafts.

Apr 2026Designing AI products you can depend onThis post shifts the focus from AI as a feature to AI as a design material, emphasizing the importance of product design around AI models to build dependable AI products. It introduces design levers such as inference latency, model size vs. performance, explainability, traceability, and robustness. Key principles for collaborative AI are outlined: exposing intent before output, designing for decomposition, surfacing uncertainty, and assuming human participation. The role of language and content design in shaping AI behavior is highlighted, along with the concept of bounding AI creativity based on task sensitivity and tolerance for variance. Measurement strategies are updated to focus on user experience signals like output structure, tone consistency, verbosity, and correction cost. The post concludes by emphasizing that dependability is designed, not assumed, and is earned through intentional product choices that keep humans in the loop.

Apr 2026Rovo Dev Driven Development - How we built a platform in 4 weeksThis post details the development of 'Fireworks', a platform for running Firecracker microVMs on Kubernetes, serving as the execution engine for Atlassian's AI agent infrastructure. It highlights the technical challenges and solutions involved in building a scheduler, autoscaler, node agents, envoy ingress layers, and raft persistence. The post emphasizes an agentic development workflow where AI agents are given end-to-end access to the SDLC, including writing e2e tests, deploying to isolated dev shards, and interacting with CI pipelines and PRs. It also discusses the use of skills for domain-specific actions and sub-agents for adversarial review, with a focus on black-box validation of system outputs rather than code inspection. The integration of Bitbucket and Pipelines within the agent's conversational interface is noted as a key enabler.

Apr 2026Build smarter with Claude Opus 4.7 and deep Atlassian context in Rovo DevThis post announces the availability of Claude Opus 4.7 within Rovo Dev CLI and IDE, and a limited-time promotion for Rovo Dev Standard customers to use it at a lower credit multiplier. It also provides instructions on how to switch models and efficiency levels using slash commands.

Apr 2026Rovo Dev in Frontend Platform Engineering - AI for small tasks, AI for big tasksThis post details the application of Rovo Dev (an AI agent platform) to automate and assist in large-scale frontend platform engineering tasks, specifically the migration of `styled-components` to `@compiled css-in-js`. It outlines how Rovo Dev can be used for planning (classifying changes, building PoCs), writing orchestration and validation harnesses, and executing migrations with minimal human supervision. The post highlights the use of Rovo Dev for analyzing code, generating migration instructions, creating playgrounds for testing, and implementing automated validation through VR tests and style snapshot testing. It also describes the use of Jira for tracking progress and managing sub-tasks executed by specialized sub-agents. The migration experiment resulted in migrating the majority of usages within 3 days with estimated 14 engdays of effort using the 'artisan way'.

Apr 2026Enhancing Developer Workflow with Rovo Dev and NotificationsThis post introduces the integration of Rovo Dev CLI with Peon Ping, an open-source notification layer for developers. Peon Ping provides concise audio cues and optional desktop toasts for tool events, aiming to preserve developer focus and shorten feedback cycles. The integration allows Rovo Dev to trigger notifications when tasks complete, error, or require input, and intelligently avoids notifications when the terminal is not frontmost. Installation involves `brew install PeonPing/tap/peon-ping` and `peon-ping-setup`.

Apr 2026Introducing Agentic Pipelines: AI automation for chores devs don’t want to doThis post introduces 'Agentic Pipelines' within Bitbucket Pipelines, enabling the orchestration of AI agents to automate tedious development chores. It provides a concrete example of an agent that automatically updates README files based on code changes, raising a PR for review. The post also details five additional use cases with public repository examples: automated security vulnerability identification and fixing, feature flag cleanup, release note generation, PR summarization, and ensuring test coverage quality. The technical implementation involves defining agents in `bitbucket-pipelines.yml` with specific prompts, constraints, and required scopes for repository access. The system is currently in open beta.

Apr 2026Behind the scenes of Atlassian’s AI Builders WeekThis post details Atlassian's AI Builders Week, an internal event focused on upskilling Product Managers and Designers in AI skills, particularly advanced agentic workflows and production-ready prototyping. It highlights the creation of 298 agents, a 15-20x spike in Rovo Dev usage, and the integration of AI tools like Rovo Studio, App Builder, and Cursor into the development process. The event emphasizes learning through hands-on building, dogfooding Atlassian's AI and dev tools, building practical agentic workflows, and bold experimentation. Specific curriculum elements include building reusable agents, running no-code evals, extending Jira/Confluence/JSM with App Builder, and using Rovo Dev for code changes. A key example is a Loom growth designer using Cursor and Rovo Dev to build a live, code-based prototype for Loom's 'Make Edits' panel, demonstrating how product and design can own and refine interaction details directly from prototypes.

Apr 2026Rovo Chat in Bitbucket now understands your PipelinesThis post introduces Rovo Chat's integration with Bitbucket Pipelines, enabling users to ask natural language questions about pipeline failures and receive explanations, root causes, and suggested fixes. It leverages pipeline run status, failing steps, logs, and configuration, combined with an LLM, to provide context-specific answers. Future work will include taking actions within the chat and providing deployment intelligence.

Apr 2026The Atlassian Rovo MCP Server now supports Bitbucket CloudThis post announces the integration of Bitbucket Cloud tools with the Atlassian Rovo MCP Server. This extends the AI-native software development capabilities previously focused on Jira and Confluence to include repository browsing, commit creation, pull request management, and pipeline status checks within Bitbucket Cloud. It introduces specific Bitbucket tools like bitbucketWorkspace, bitbucketRepository, bitbucketPullRequest, bitbucketRepoContent, bitbucketPipelines, bitbucketDeployments, and bitbucketEnvironments to the MCP Server's available toolset. The post also details current limitations (org-linked workspace, API token auth) and future roadmap items (OAuth support, more tools).

Apr 2026Creating with Rovo: How We Built a Collaborative AI CanvasThis post details the technical implementation of a collaborative AI canvas for content creation within Atlassian's Rovo AI solution. It covers the design principles of creation living inside chat and being a platform, not a feature, with real-time streaming. Key technical contributions include: 1. A new Confluence creation and editing skill agent for Rovo. 2. LLM output formats for different content types: ADF (nested JSON) with a repair library for pages, SVG for whiteboards (converted to native elements), and CSVs (schema, views, data) wrapped in XML for databases. 3. Agentic loops with reflection for page editing using editor-style commands. 4. Real-time SVG parsing and constraint solving for whiteboard assembly. 5. A streaming API contract for LLM actions and the Rovo Bridge API for bidirectional communication between chat and content objects, abstracting transport layers (BrowserTransport, DesktopTransport) and using JSONRPC over the chosen transport. 6. Offline evaluations using screenshot-based assessment and online evaluations tracking success rates, alongside automated health checks for agentic flows.

Mar 2026Agent Context Pruning: How Rovo Dev keeps long sessions usefulThis post introduces the concept of agent context pruning as a core capability for maintaining long-running AI agent sessions. It details a structured, multi-stage pruning process that prioritizes least-destructive operations, such as trimming large tool outputs and redundant intermediate steps, before resorting to more aggressive methods like summary collapse. The system protects the beginning of the conversation (task definition) and the most recent interactions (local coherence). It contrasts this structure-aware pruning with LLM-based compaction, highlighting the former's advantages in speed, cost, and preservation of original conversation structure. The post emphasizes that pruning is essential for agents to handle complex software tasks over many interactions by intelligently deciding what to remember, compress, or forget.

Mar 2026MCP Compression: Preventing tool bloat in AI agentsIntroduced mcp-compressor, an open-source MCP proxy that wraps existing MCP servers to reduce tool-description token usage by 70-97%. The proxy replaces a server's full tool inventory with generic wrapper tools (get_tool_schema, invoke_tool, optionally list_tools) to enable on-demand schema fetching. This reduces prompt costs, improves cache behavior, and scales to multiple servers. The post details configurable compression levels and their impact on token counts, and discusses design principles like preserving structure, namespacing, cache-friendliness, and explicit discovery paths. It also contrasts this approach with code-mode execution.

Mar 2026Delivering 120 PRs in two weeks with Rovo Dev in JiraThis post details the author's personal experience using Rovo Dev in Jira to accelerate development. It highlights the ability to delegate low to medium complexity tasks to a coding agent, resulting in the opening and merging of over 120 pull requests in two weeks. The author describes offloading work to remote sandboxes, automating task creation from Slack conversations into Jira work items, and using the agent for code generation, refactoring, and contributing to unfamiliar codebases. Specific tips are provided on using cheaper models for minor changes, reviewing AI-generated PRs, and using the agent for initial investigation and breaking down complex tasks. The post also touches on the potential for future integrations, such as directly addressing review comments and automatically fixing CI failures.

Mar 2026Turn Loom meetings and bug reports into Jira work with AIThis post introduces new AI workflows for Loom that integrate with Jira and Rovo. The enhanced bug reporting mode automatically captures technical context (browser, device, network, console logs) and turns it into a dev-ready Jira work item. AI-suggested Jira work item updates based on Loom meeting recordings are also introduced to capture decisions and action items, keeping Jira boards up to date with less manual follow-up. The integration aims to compress the journey from issue discovery to fix by automating the capture of critical technical details and facilitating work breakdown and requirement initiation via Rovo.

Mar 2026Advancing semantic search for millions of Rovo usersThis post details advancements in Rovo's semantic search capabilities, focusing on the evolution of embedding models (MiniLM, BGE-large, EmbeddingGemma-300m) and the rationale behind their selection based on quality, latency, and cost. It explains the hybrid retrieval approach combining traditional signals with neural semantic understanding for improved relevance. The post also highlights task-aware search tailoring results to user context (Jira, Confluence) and discusses future investments in deeper work context modeling, proactive assistive behavior, tenant-specific embedding fine-tuning, and the integration of AI agents. A significant technical contribution is the collaboration with NVIDIA, leveraging their accelerated computing and AI software stack (Llama-Nemotron-Embed-1B-V2, NeMo Data Designer, NeMo Automodel) to achieve a 26%-40% uplift in retrieval quality through fine-tuning. The post also mentions the use of NVIDIA NeMoClaw and OpenShell runtime for agentic AI.

Mar 2026Using Rovo Dev in VS Code for Architecting SolutionsThis post details the application of Rovo Dev within VS Code to streamline the software development lifecycle. It outlines a three-step process: 1. Extracting key decisions, trade-offs, and assumptions from conversations (Loom, Slack, Confluence) to draft high-level proposals. 2. Delegating specific design areas like API contracts, data flows, integration points, non-functional constraints, and edge-case handling to Rovo Dev, using RFCs and codebase context to propose detailed designs. 3. Using Rovo Dev to generate a Jira breakdown into Epics and Work Items, and then incrementally implementing code, generating test cases, and validating changes. The post emphasizes the integration of Rovo Dev as an orchestration layer connecting discussions, specifications, and code.

Mar 2026Rovo Dev CLI Ralph Wiggums Loop for Large Scale Test RefactoringThis post details the application of the Rovo Dev CLI's 'Ralph Wiggums Loop' for large-scale test refactoring. The workflow involved identifying target files using Rovo Dev, refining these into actionable Specs by linking to Confluence pages and previous PRs, and processing one file per iteration. Bottlenecks in local test execution were noted, with suggestions for batch testing. The loop was made failure-proof by flagging timeouts and identifying partially optimized files. A key lesson learned was the need to summarize learnings compactly for subsequent runs to manage Spec file size and maintain AI agent effectiveness. The outcome was 160 files of changes, with most tests working out-of-the-box and significant speed improvements.

Mar 2026From Days to Hours: Accelerated K8s Debugging with Rovo Dev CLIThis post details the application of the Rovo Dev CLI to debug a production issue involving GCP Ingress and OpenSearch. The Rovo Dev CLI was used to analyze Jira tickets and Confluence documentation, enable GCP Load Balancer logging, identify a subtle Host header mismatch (':443' suffix) causing 404 errors, and generate a reproducible test case. The fix involved configuring a default backend for the GKE ingress to route unmatched requests to OpenSearch. The post emphasizes the speed, repeatability, knowledge sharing, and gap-filling benefits of using the Rovo Dev CLI for debugging complex infrastructure issues.

Mar 2026Automating Mutation Coverage with AI: Our Journey and Key LearningsIntroduces the Mutation Coverage AI Assistant, a Dev-in-the-loop system leveraging Rovo Dev CLI to automate the improvement of mutation coverage. The assistant analyzes mutation reports, recommends classes to target, writes tests aligned with project conventions, and auto-validates coverage improvements. Key learnings include the need for package-level analysis for large projects, tightening LLM instructions to avoid common mistakes (e.g., modifying implementation classes, wildcard imports, meaningless assertions), and providing detailed, mutant-specific test-writing guidelines to generate focused, high-quality tests. The post also highlights that AI cannot fix underlying design issues like bloated classes, and emphasizes the importance of collaborative prompt evolution.

Mar 2026How We Turned Feature Flag Cleanup Into a Mostly‑Hands‑Off AI WorkflowThis post details the implementation of an AI-driven workflow for feature flag cleanup. It describes the creation of repo-tailored AI commands using Rovo Dev CLI and Jira Automation, enabling automated PR generation for cleanup tasks. The process involves specializing AI prompts to understand the specific feature flag framework, code paths, and testing conventions of the repository. A self-improvement loop using Rovo Dev's 'improve-command.md' prompt is described to enhance the AI's effectiveness, raising the success rate of cleanup PRs to 8 out of 9 requiring no manual intervention. A Jira-driven queue mechanism is introduced to manage the execution of cleanup tasks, preventing merge conflicts and ensuring a consistent flow of work. The outcome is a highly automated, hands-off workflow that significantly improves code hygiene and developer productivity.

Mar 2026How Rovo helps teams start work 30% fasterThis post details the analytical methodology used to measure the impact of Rovo AI on user productivity within Jira. It defines 'Lead Time to Start' (time from creation to 'In Progress') and 'Number of work items moved into In Progress' as key metrics. A quasi-experimental design with control and test cohorts (regular Rovo users vs. non-users) was employed. Filters included paid Jira licenses (premium/enterprise), 50-1000 seats, and user tenure of at least 180 days. Winsorization excluded the bottom and top 10th percentile of 'Lead Time to Start' values. A normalized timeline ('Day 0' for Rovo adoption, 'Day 45') was used, with control group 'Day 0' dates randomly assigned from the test group's distribution. A two-sided t-test with significance 0.05 and power 0.8 was used for comparison. Findings indicate a statistically significant 30% improvement in work items moved to 'In Progress' and a 35% reduction in 'Lead Time to Start' for Rovo AI adopters.

Mar 2026Architecting a Rovo AI Teammate: From AI 'Magic' to Production-Ready Forge CodeThis post details the engineering process of building a production-ready Rovo app for team event planning. It describes the transition from initial natural language interaction in Rovo Studio to architecting the agent's logic using the RACE framework (Role, Action, Context, Execute) for structured prompts. The author explains the process of building custom Forge skills to integrate with Confluence, emphasizing the need to use official API documentation for syntax. Authorization is handled by scoping agent permissions to a dedicated Confluence space. The post also includes a link to the source code for the 'Team Event Planner' app.

Mar 2026Supercharge your Security Testing with Rovo Dev SkillsThis post introduces the use of Rovo Dev Skills to enhance security testing workflows. It details how to integrate external static analysis tools (like Semgrep, TruffleHog), perform AI-assisted code auditing, triage findings, and generate prioritized test leads. The post explains the concept of Rovo Dev Skills as an open format for agent instructions and provides examples of specific skills for security analysis, including language analysis, SAST scanning, secret scanning, endpoint enumeration, AI code auditing, CVSS scoring, SAST result triage, and lead generation. It also discusses when to use Skills over MCP integrations for simpler CLI tools.

Feb 2026Extend what Rovo can do across your stack with MCPThis post introduces the integration of third-party applications with Rovo agents via the Model Context Protocol (MCP). This allows Rovo agents to pull live data and take actions in external applications such as Amplitude, Box, Canva, Figma, GitHub, Intercom, New Relic, and Replit. It also details pre-built agents for Figma, Intercom, Box, and Canva, and introduces Rovo Studio for custom agent creation. The ability to connect agents to internal systems via MCP is also highlighted.

Feb 2026From agent sprawl to seamless alignment: Introducing agents in JiraThis post introduces the open beta of AI agents within Jira, allowing agents to be assigned work items, @mentioned in comments for collaboration, and integrated into Jira workflows. It details how agents appear as assignees, enabling tracking of their progress and accountability. The integration allows for in-context collaboration via comments and the execution of discrete jobs within workflows. The system leverages Atlassian's existing permissions, project configurations, and audit trails, and supports both Rovo agents and third-party agents via the MCP (Model-Centric Platform) framework. This evolution aims to orchestrate teams of people and AI agents within Jira.

Feb 2026Redesigning a Homepage in 20 Minutes: Figma MCP + Atlassian Design System MCP + Rovo Dev CLIThis post details an AI-powered workflow for rapidly redesigning an application homepage from Figma to production-ready React code using Figma MCP, ADS MCP, and Rovo Dev CLI, collapsing a multi-day effort into minutes by automating the translation of design data into ADS-compliant components and code, including iterative testing and issue resolution. It demonstrates the integration of Figma design data, Atlassian Design System (ADS) components and tokens via its MCP server, and Rovo Dev CLI for code generation and testing. The workflow involves extracting design context from Figma, querying ADS MCP for component APIs and tokens, reading project code patterns, generating new React components using ADS primitives and tokens, composing the layout, and iteratively fixing issues identified by the test suite (React.lazy wrapping, duplicate text, accessibility violations).

Feb 2026AI User Experience PatternsThis post introduces four new AI user experience patterns: AI Form Filling, Ghost Text Completion, Proactive Anticipatory Triggers, and Memory Modularity & Workspace Context. It details the AI Form Filling pattern with a Forge app example that uses the Forge LLM API to populate form fields with JSON responses. The other patterns are described conceptually with potential usage examples in Atlassian products.

Feb 2026Welcome to the future of creating and editing in Confluence with Atlassian RovoThis post introduces the integration of Rovo AI agents with Confluence for content creation and editing. It highlights how users can leverage natural language prompts to generate structured drafts, refine existing content, and pull context from various Atlassian and third-party applications via the Teamwork Graph. The focus is on overcoming blank page anxiety, grounding content in real work, and simplifying the editing process. Example prompts are provided for marketing, product, and HR use cases. This extends the AI-native capabilities by focusing on content generation and editing workflows within Confluence.

Feb 2026Rovo Dev is now generally available in VS CodeThis post announces the general availability of Rovo Dev in VS Code, integrating it into the Atlassian VS Code extension. It highlights how Rovo Dev, powered by the Teamwork Graph, provides context-aware AI assistance within the IDE for planning, coding, reviewing, and shipping. Key features include starting tasks faster by querying code, Jira, and Confluence; automating busywork like drafting Jira items and PRs; staying in flow with work suggestions and task management; receiving instant alerts; and leveraging organizational context from Atlassian and third-party tools. Example workflows for tackling Jira work items and creating/reviewing PRs are detailed.

Feb 2026Atlassian Rovo MCP Server is now GAThis post announces the General Availability (GA) of the Atlassian Rovo Model Context Protocol (MCP) Server. It details how the MCP Server acts as an enterprise-ready, Atlassian-hosted infrastructure that allows a broad set of AI clients to securely connect with Jira and Confluence. Key new capabilities include: Rovo search and fetch across Jira/Confluence from external AI clients, creation and update of Confluence pages, and creation and linking of Jira epics/issues directly from AI clients. It also highlights support for MCP apps delivering tailored UI experiences and emphasizes enterprise-grade security, admin, and AI controls such as trusted client management, MCP usage logs for visibility, and alignment with existing Rovo/Atlassian platform controls. The post reinforces Atlassian's commitment to an open ecosystem for AI.

Jan 2026Introducing Rovo Think Deeper: Stronger reasoning, right when you need itThis post introduces 'Think Deeper' for Atlassian Rovo, a new reasoning mode that sits between standard chat and deep research. It enhances Rovo's ability to handle complex queries by dynamically breaking them into subtasks, iterating on intermediate results, and leveraging the Teamwork Graph for context. The system automatically selects the appropriate reasoning level (Standard Chat, Think Deeper, or Deep Research) based on prompt complexity, with users able to manually engage 'Think Deeper' for more thorough analysis. The core technical contribution is the 'deliberate reasoning loop' that plans, iterates, connects via the Teamwork Graph, and verifies results before presenting them to the user.

Jan 2026How Atlassian cut PR cycle time by 45% with AI code reviewsThis post details the integration of Rovo Dev, an AI developer agent, into Bitbucket for code reviews. It highlights three key areas of improvement: instant feedback on code quality using LLMs, enforcement of organizational engineering standards (lint rules, design patterns, security, compliance, API contracts) by pulling context from Confluence, and ensuring PRs meet Jira acceptance criteria by connecting to Jira work items. The post quantifies the impact by stating a 45% reduction in PR cycle time and a 5-day faster first PR merge for new engineers using Rovo Dev. It also mentions beta results showing a 32% reduction in customer PR cycle time.

Jan 2026Streamlining your Rovo Dev CLI workflow with event hooksIntroduces Event Hooks to the Rovo Dev CLI, allowing users to script custom behavior triggered by agent lifecycle events (e.g., generation completion, error, tool permission requests). Provides examples for sending notifications, running linters/builds/tests, and opening log files. Details a quick start for playing a sound notification when tool permissions are requested.

Jan 2026How Rovo solves search challenges through entity linkingThis post details the Entity Linking service, a core component of Rovo, which transforms unstructured text into structured knowledge by accurately associating textual mentions with specific records in the Knowledge Graph. The service identifies mentions in text and connects them to their corresponding unique entries, serving RAG & Chat, Search Relevance, and Knowledge Indexing. It tackles challenges like high variance, low distinctiveness, noise, volatility, contextual dependence, sparse metadata, diverse naming conventions, and privacy constraints, particularly for Team Names. The solution employs a cascade architecture with detection (transformer-based sequence tagging), recall (user relation, lexical, and embedding-based paths), and ranking (XLM-RoBERTa cross-encoder and LLM-powered relevance scoring) stages. Future work includes one-hop relation resolution and implicit/virtual team identification.

Jan 2026How Specialised Sub-Agents Enhanced Rovo Dev CLI Reliability for My ProjectThis post details a personal experimentation with Rovo Dev CLI, moving from a single monolithic AI agent to a network of specialized sub-agents coordinated by a main orchestrator. This architecture includes dedicated agents for backend, frontend, testing, performance, architecture, history logging, documentation, and Git/quality gating. The key technical contribution is the demonstration of how agent specialization and orchestration can significantly improve reliability, reduce regressions, and enhance the predictability of AI-assisted software development, particularly as codebases grow.

Jan 2026Improving product analytics with Rovo Dev CLIThis post introduces the Rovo Dev CLI's new SQL Writer sub-agent, designed to automate the generation of production-grade SQL queries for product analytics. The agent accesses existing SQL scripts, Confluence documentation on metrics and schemas, and follows a three-step workflow (Understand, Plan, Write) to produce readable, runnable, and well-structured queries. It acts as an 'analytics engineer in the loop', accelerating the translation of natural language questions into SQL, enforcing consistency, and lowering the skill barrier for data analysis.

Jan 2026Using Rovo Dev multi‑stage prompts for refactoring UI componentsThis post introduces and demonstrates a multi-stage prompting strategy for using AI tools like Rovo Dev to refactor UI components. It details a four-stage process: refactoring a component to accept dynamic data, integrating it into a parent component, adapting to requirement changes by simplifying identifier passing and enhancing links, and updating mock data for testing. The core contribution is the methodology of breaking down complex AI tasks into smaller, focused prompts to improve accuracy, reviewability, and control over AI-generated code changes.

Dec 2025Accelerating Innovation: How Atlassian Williams F1 Team Drives Success with RovoThis post details how the Atlassian Williams F1 Team uses Rovo to unify simulation experiment knowledge by documenting methods, assumptions, and insights in Confluence, making them discoverable and actionable via Rovo search, chat, and agents, accelerating access to critical information and reducing time spent searching. It also describes how Rovo and Jira are used to automate and streamline trackside IT checks, from task assignment to incident logging and real-time dashboards.

Dec 2025The 2025 Year in Review (and what's coming soon)This post announces the integration of Rovo Chat and Rovo Dev into Bitbucket, extending AI-powered capabilities beyond code generation to the entire SDLC. Key contributions include AI-assisted code review (cutting PR cycle times by 45%), a pipelines troubleshooter that scans logs and suggests fixes, and a pipelines deployment summarizer. Future plans include agentic CI/CD in Bitbucket Pipelines for natural language automation of complex tasks and AI-powered test management for triaging and fixing flaky tests. Rovo Chat in Bitbucket will provide context-aware answers about code ownership, documentation, and Jira/repository relationships.

Dec 2025Spec Driven Development with Rovo DevThis post introduces Spec-Driven Development (SDD) as a methodology to improve interactions with AI coding agents. It contrasts SDD with 'vibe coding' by highlighting the importance of planning, review, and iteration. The post defines SDD as a process where specifications drive planning, task breakdown, and validation, emphasizing structured collaboration between humans and agents. It provides a contrived example of building a structure and details the structure of an SDD instruction prompt, including breaking down requests into small, verifiable steps, documenting plans in a temporary directory, and summarizing results for review. The post also demonstrates a practical application of SDD in RovoDev for consolidating benchmark scripts, showcasing how the iterative review process helps catch and correct flawed plans before execution.

Dec 2025Mobbing with AIThis post introduces and details a new development workflow called "Mobbing with AI" that combines traditional mob programming with AI-assisted development tools. It outlines the process, including defining standards, specifying tasks, and a feedback loop between the mob and AI for code generation, testing, and refinement. The post highlights the use of specific Atlassian AI tools like Rovo Dev CLI, in-editor AI assistants, Rovo Chat Agent, and Rovo Dev Code Review for Bitbucket. It also details how AI is leveraged for requirements gathering, spikes, prototyping, and design/architecture, and shares the positive results observed in terms of speed, code quality, and shared understanding.

Dec 2025How to effectively utilise AI to enhance large-scale refactoringThis post details a practical, end-to-end approach for using AI (primarily Rovo Dev, but can be migrated to other AI agents) to identify and remove new Navigation (Nav4) feature gates (FG) and mocks across the monorepo of Atlassian Frontend. It shares the experience using AI to enhance cleanup and lessons learned. The objective is to provide a repeatable, safe, and scalable workflow to use AI for large-scale codebase refactoring, specifically removing all Nav4 FGs and mocks with quality and speed. The approach involves making AI a good coder by establishing a durable AI context using a `memory` file to guide Rovo Dev in code generation, edit interpretation, and workflow assistance during each session. A discovery prompt is used to enumerate all Nav4 FG and mock patterns. A package-level cleanup method is defined using AI to perform targeted, high-quality transformations that can be reused across multiple packages, then used to drive code changes. Multiple threads are conducted to make code changes with DevBox. Key takeaways include that AI can think, not just be a script generator, codified context acts as a force multiplier, batching with tight feedback loops keeps large changes safe, discovery prompts turn ambiguity into a concrete plan, and quality comes from guardrails, not blind trust. The post also outlines next steps for creating an automated E2E workflow leveraging AI to modify code.

Dec 2025Powering the agentic ecosystem with Atlassian Rovo MCP ServerIntroduces the Atlassian Rovo MCP Connector for ChatGPT, enabling users to leverage Jira and Confluence context within ChatGPT for summarization, insight generation, and action-taking (e.g., creating Jira issues). Enhances the Atlassian Rovo MCP Server with OAuth authentication, audit logs for tool invocations, and a supported domains allowlist for enhanced security and control over connected MCP clients. This expands the agentic ecosystem by integrating with a widely used AI tool.

Dec 2025How Rovo Chat embraces multi-agent orchestrationThis post details the evolution of Rovo Chat's architecture from a single-agent framework to a hierarchical multi-agent system, and then to a hybrid orchestration model. It explains the rationale behind this evolution, focusing on improved subtask decomposition, domain specialization of agents (e.g., Jira Agent), the use of system tools, and different reasoning modes (Brainstorming, Tool QnA, Reasoning). The post also contrasts the hybrid model with previous single-agent and DAG-based approaches, presenting evaluation data on quality and latency improvements. Key technical contributions include the concept of domain-specialized subagents as tools, the processing of large volumes of Jira issues via iterative refinement, and the hybrid orchestrator's ability to dynamically select and execute tools one step at a time.

Nov 2025Ship faster with focused Subagents in Rovo Dev CLIThis post introduces the concept of 'subagents' within the Rovo Dev CLI. Subagents are specialized AI helpers that break down large prompts into smaller, manageable units. Key technical contributions include: defining the benefits of subagents (reproducibility, contract-first outputs, least-privilege execution, context discipline, parallelization, team reuse, faster feedback loops), detailing interactive and manual configuration methods for subagents, providing example prompts for code review and test generation, illustrating the subagent lifecycle and delegation flow, and outlining practical patterns for their implementation (narrow scope, explicit prompts, standardized outputs, stacking). It also highlights gotchas related to context supply and scope selection.

Nov 2025Automating Customer Support with JSM Virtual AgentThis post details the evolution of the JSM Chat architecture, introducing a unified orchestrator service and channel categorization (streaming vs. non-streaming) to address inconsistencies in bot responses across different channels. It describes the routing strategy for the Virtual Agent (VA), which prioritizes intent matches for premium customers or falls back to AI-generated answers. The AI deep dive covers personalization, Retrieval-Augmented Generation (RAG) with multiple search sources (Jira tickets, knowledge bases), and safeguards against hallucinations. The search and ranking mechanism is explained, detailing the use of similarity scores, cross-encoder scores, and Reciprocal Rank Fusion (RRF) to extract relevant passages. The impact of the JSM Virtual Agent is quantified with metrics on resolution rate and CSAT scores. Further improvements like query variation, vague query detection, and a Chain-of-Thought (COT) based hallucination detector are also discussed.

Nov 2025Rovo Dev agent, now available in the CLIThis post announces the general availability of the Rovo Dev CLI, which brings agentic AI capabilities to the command line. It details how the CLI transforms the terminal into an intelligent development agent that understands, codes, and collaborates within the Atlassian ecosystem. Key features highlighted include code understanding and navigation, development acceleration (code completion, refactoring, testing, debugging), seamless integration with Jira, Confluence, and Bitbucket, and enhanced security and administration features like permission controls and usage monitoring. The post also emphasizes Rovo Dev CLI's top performance on the SWE-bench benchmark and provides examples of how teams are using it for code exploration, integration with Atlassian tools, adaptive memory, and code migration assistance.

Nov 2025Reimagining software delivery with AI-powered workflows in Jira & BitbucketThis post introduces agentic AI workflows within Bitbucket Pipelines, enabling AI agents to interact directly with Bitbucket Cloud via a custom MCP server. New pipeline triggers (package publication, deployment completion, flaky test identification) and agentic steps are introduced, allowing natural language instructions to execute AI agents for coding tasks, pull request management, and log analysis. Rovo Dev's capabilities are expanded to include generating code from Jira issues, creating Bitbucket PRs, generating PR summaries, performing AI-powered code reviews, and diagnosing/fixing build failures. The post also highlights upcoming test management features within Bitbucket.

Nov 2025Atlassian Rovo Dev Research: What Types of Code Review Comments Do Developers Most Frequently Resolve?This post details research on code review comment types and their resolution rates, comparing human reviewers with the Rovo Dev AI agent. It introduces a classification system for comments (readability, bug, maintainability, design, no issue) and uses GPT-4 for classification with expert validation. The research found Rovo Dev generates more bug and maintainability comments, while humans focus more on readability and design. Crucially, developers resolve readability, bug, and maintainability comments at higher rates (36-43%) than design comments. This research informs Rovo Dev's focus on actionable, resolvable comments to improve code review efficiency and quality.

Oct 2025Introducing Atlassian Software CollectionThis post announces the Atlassian Software Collection, which bundles Rovo Dev, Bitbucket Pipelines, Bitbucket, Compass, and DX. Rovo Dev is now generally available and is highlighted as an AI teammate for planning, coding, reviews, and automation, leveraging the Teamwork Graph for organizational context. Specific Rovo Dev capabilities demonstrated include CLI workflows, automated code reviews in Bitbucket and GitHub, and future Jira integration for end-to-end task automation. The post also details the upcoming acquisition of DX, which will contribute measurement of AI adoption and impact, developer experience insights, and productivity metrics to the collection. The overall theme is the integration of AI into the SDLC to improve developer joy and productivity.

Sep 2025Meet Rovo Chat in Bitbucket: your AI-powered teammateThis post introduces Rovo Chat in Bitbucket Cloud, an AI-powered teammate that provides in-context insights directly within the Bitbucket workflow. It enables faster PR reviews by summarizing code changes and comments, aids in onboarding to new repositories by explaining their purpose and key APIs, and retrieves project context from Jira and Confluence. It also summarizes documentation and explains unfamiliar code. The feature is available on Bitbucket Standard and Premium plans and requires connecting Bitbucket to Jira and enabling AI features. Data indexed includes Bitbucket pull requests and repositories, open code, and connected Rovo data sources. Future capabilities will include full codebase indexing and CI/CD insights.

Sep 2025Rethinking UX: how Opus Guard built AI-assisted Data Governance with Rovo and ForgeOpus Guard integrated Rovo Agents and Actions into their Confluence Content Retention Manager app to provide AI-assisted content classification. This integration leverages Rovo Chat to allow users to request classification levels, view content classification, and set classification levels. The agent uses Rovo Actions (fetch-content, fetch-classification-levels, fetch-content-classification-level, set-content-classification-level) to interact with Confluence data. The prompt engineering for the agent defines workflows and jobs, and response handling customizes the output. Marketplace Agents, unlike Studio Agents, require explicit Rovo Actions for knowledge retrieval. Security considerations for Rovo Actions are managed through Forge's defined permissions and governance model, ensuring data remains within Atlassian Cloud.

Aug 2025Improving Coding Agent ExperienceThis post details improvements in identifying suitable work items for coding agents by analyzing indicators like description length, link ratio, presence of file paths, code snippets, and technical terms. A classical ML model is used for classification, providing feedback to users on improving work item descriptions. Additionally, the 'similar work items' feature leverages Jira AI to fetch semantically similar work items with associated PR diffs as context for coding agents, improving resolution rates for infrastructure updates and feature changes.

Aug 2025Comment ranker - An ML-based classifier to improve LLM code review quality using Atlassian’s proprietary dataThis post details the development and impact of the 'comment ranker,' an ML model designed to improve the quality of code reviewer agent comments. It describes the binary classification task of predicting comment resolution rate (CRR) using a fine-tuned ModernBERT model. The ground truth is derived from Atlassian's internal dogfooding data, where user code changes after a comment indicate value. The model's training, fine-tuning process, and the importance of model refresh due to data drift are explained. The post highlights the comment ranker's success in increasing CRR, its adaptability to different LLMs (GPT-4o, Claude Sonnet 3.5), and positive user feedback, positioning it as a proprietary moat for Atlassian's code review capabilities.

Aug 2025Atlassian’s AI Gateway: Best in Class Model GardenThis post introduces Atlassian's AI Gateway, a new internal platform designed to abstract and manage access to a diverse range of LLMs and AI models from multiple providers. Key technical contributions include a unified API contract for integration flexibility, automated fallback mechanisms for LLM unreliability, centralized enforcement of security, privacy, and compliance controls, and robust quota and cost management. The gateway also provides shared tooling for developers, integrates with Atlassian's AI Evaluation suite and ML Studio for synthetic data generation and testing, and supports rapid iteration through integration with Atlassian's Prompt Registry. It enables Atlassian developers to easily switch models, perform A/B tests, and deploy AI features with production-ready capacity and compliance.

Aug 2025Rovo Dev CLI releases with GPT-5 supportThe Rovo Dev CLI has been updated to support OpenAI's GPT-5 model, which offers improved reasoning, code quality, and efficiency. This update amplifies the CLI's existing capabilities, which previously achieved a 41.98% resolve rate on the SWE-bench benchmark. The CLI now also supports image and PDF file input, enhanced copy commands, and improved session management.

Aug 2025How Rovo Deep Research works - Inside Atlassian How Rovo Deep Research worksThis post details the introduction of 'Deep Research,' a novel feature within Rovo Chat that enhances information retrieval and report generation for complex inquiries. It elaborates on the enhanced RAG architecture, including query-dependent retrieval and content-grounded answer generation. Key technical contributions include the transition from single-path to multiple-path information retrieval by decomposing tasks into sub-tasks, and implementing structured report generation through outlining, parallel section development, and integration. The post also highlights the use of Atlassian's Teamwork Graph for foundational data, the iterative reflection and refinement of results, the generation of reports with in-line citations and exportability to Confluence, and the specific reasoning models employed (Llama 3.2 8B, GPT-4o, GPT-4.1, Claude 3.7 Sonnet). It also outlines the evaluation framework for measuring response quality and the challenges addressed, such as limited depth of insight and insufficient source attribution.

Jul 2025The AI Technologies Behind Speech Editing at LoomThis post details the AI model architecture behind speech editing at Loom, focusing on zero-shot learning and Masked Acoustic Modeling (MAM). It explains the end-to-end workflow, including waveform to MelSpectrogram conversion, text normalization using NeMo-text-processing, and phonemization with Espeak. Challenges with accents and names are discussed, along with the use of a custom phonetic spelling lookup table. The core of the system is a universal model capable of generalizing to new voices and acoustic environments without user-specific fine-tuning, which simplifies management, reduces inference delays, and lowers costs.

Jul 2025Rovo drives a new era for conversational AIThis post details recent improvements to Rovo Chat, enhancing its intelligence and usefulness by deepening the integration with Atlassian's Teamwork Graph. Key technical advancements include: 1. Intent Routing: Rovo now intelligently analyzes prompts to determine if a quick search or a deep graph query is needed, based on whether the prompt references work, teams, goals, and projects. This ensures efficient retrieval of relevant information. 2. Designed to prompt clarity: Rovo asks clarifying questions for ambiguous prompts (e.g., multiple people with the same name) to ensure accurate answers. It then fetches data from the Teamwork Graph and delivers detailed, context-rich answers with links, metrics, and next steps. 3. Personalized Summaries: Rovo can now generate personalized summaries of missed updates or work done, filtering out noise and highlighting important information grouped by team or project. These improvements have led to a 29% higher satisfaction rating in blind human evaluations.

Jul 2025Atlassian’s Inference Engine, our self-hosted AI inference serviceThis post details the creation and architecture of Atlassian's Inference Engine, a self-hosted AI inference service. It highlights the technical challenges of scaling AI workloads, the decision to build in-house to avoid vendor lock-in and improve control, and the resulting performance and cost benefits. Key architectural components include Kubernetes, Karpenter, ArgoCD, Helm, NVIDIA Triton Inference Server, TensorRT-LLM, and vLLM. The post elaborates on the GitOps deployment model for reliability and traceability, and the optimization stack for model inferencing. It describes the control plane for model preparation and the data plane for serving inference at scale, including details on node provisioning (Karpenter), ingress routing (Istio), autoscaling (KEDA), and observability (Prometheus/SignalFx). The post quantifies improvements in latency (up to 40% P-90 reduction for LLM) and cost savings (over 60% for LLM).

Jul 2025Rovo Chat: AI that works where you workThis post announces new capabilities for Rovo Chat, focusing on enhanced integration, actionability, and user experience. Key technical contributions include: support for over 40 file types for upload and analysis, improved formatting for pasting answers into external applications (Gmail, Google Docs, Microsoft Word) preserving tables, lists, bold text, and headings, and deeper integration with the Teamwork Graph to provide role-specific, context-aware responses. The post also highlights the ability to perform actions like creating, assigning, and transitioning Jira issues, drafting Confluence pages, and adding items to sprints directly from the chat interface, with user confirmation for all actions. The 'Deep Research' feature is introduced as a capability for generating structured, in-depth reports.

Jun 2025Introducing Rovo Deep Research, grounded on your dataIntroduces Rovo Deep Research, a new AI skill for Rovo that autonomously breaks down complex questions into research tasks, searches across Atlassian apps and connected SaaS apps, and generates comprehensive, cited reports. This skill leverages the Teamwork Graph to unify and connect data, providing context for decision-making. It aims to accelerate research, improve clarity, and enable proactive insights by synthesizing information from various sources like Jira, Confluence, and Slack.

May 2025Introducing Atlassian's Remote Model Context Protocol (MCP) ServerIntroduces the Atlassian Remote Model Context Protocol (MCP) Server, a new capability that acts as a bridge to connect Atlassian's structured knowledge (Jira and Confluence) with external AI tools and agents. This server implements the MCP protocol, an open standard for AI-tool interaction, enabling actions like summarizing work items, creating issues/pages, and performing multi-step actions. It emphasizes secure, permissioned access via OAuth authentication and is built on Cloudflare infrastructure. The initial integration is with Anthropic's Claude.

Apr 2025Human in the Loop Software Development AgentsThis post introduces HULA (Human-in-the-loop LLM-based agents framework) which automates repetitive development tasks by reading Jira work items, generating coding plans, writing code, and raising pull requests. It details the HULA process (Set context, Generate coding plan, Generate code, Raise pull request) and presents performance metrics including SWE-bench unit test pass rates (31%), GPT-based similarity to human code (45%), engineer usage statistics (79% plan generation approval, 87% code generation from approved plans, 25% to PR stage, 59% merged PRs), and survey feedback on plan alignment (36%), code understandability (61%), and code solution effectiveness (33%).

Apr 2025Bringing the magic of human-AI collaboration to every teamThis post announces the general availability of Rovo as an enterprise AI solution for all Atlassian customers, integrating search, chat, and agents into Jira, Confluence, and JSM subscriptions. It introduces Rovo Studio for building custom AI agents and automations, and highlights enhancements to Rovo Chat with 'Deep Research' capabilities. The post also details the expansion of Rovo Agents, including the 'Teamwork Collection', 'Dev AI agents', and 'service delivery-focused Rovo Agents'. The underlying Teamwork Graph is emphasized as the core data intelligence layer connecting Atlassian and third-party data for AI workflows.

Jan 2025Rovo for GitHub Copilot leads Atlassian’s new developer focused innovations at GitHub UniverseThis post introduces the Atlassian Rovo for GitHub Copilot extension, which allows developers to access Jira and Confluence data directly within their IDE via Copilot. This integration aims to reduce context switching by enabling developers to ask questions about issues, requirements, and documentation, and use this context to assist Copilot in code writing. It also highlights new AI-focused developer agents for accelerating workflows from issue to pull request and fast-tracking code reviews.

Nov 2024How to integrate GitHub Copilot with Bitbucket, Jira & ConfluenceThis post details how to integrate GitHub Copilot with Bitbucket repositories by cloning Bitbucket repos locally and using Copilot within supported IDEs. It also highlights Atlassian's Rovo Dev as a more integrated AI solution for Bitbucket, offering features like AI code review, build failure troubleshooting, AI deployment summaries, AI PR descriptions, and Rovo chat within Bitbucket. Future initiatives include generating code from Jira issues, AI-driven build fixing, and agentic CI/CD powered by Rovo Dev.

May 2024Bring more context to your code with CompassThis post introduces Compass as a developer experience platform that catalogs software architecture components and enriches them with data from across the toolchain. It details how connecting Compass to Bitbucket brings context like owner teams, dependencies, and chat channels directly into code repositories. It also highlights the ability to track DORA metrics once repos are connected to Compass. The post provides steps for getting started with Compass and connecting it to Bitbucket.

Apr 2024Generate Bitbucket Cloud pull request descriptions with Atlassian IntelligenceIntroduces AI-assisted pull request descriptions for Bitbucket Cloud Premium users. This feature leverages Atlassian Intelligence to analyze code changes and commit messages to generate PR descriptions, streamlining the developer workflow. Users can access this by clicking the Atlassian Intelligence icon in the PR description editor.

Oct 2023Atlassian Intelligence features for Bitbucket Cloud are now in beta!This post announces the beta availability of Atlassian Intelligence features for Bitbucket Cloud. It details the activation process for workspace admins and highlights the initial 'Generative AI in the editor' feature for Pull Request descriptions and comments. The post also requests feedback for future AI enhancements within Bitbucket Cloud.

Oct 2023Atlassian Intelligence features for Bitbucket Cloud are now in beta! - Inside AtlassianThis post announces the beta availability of Atlassian Intelligence features for Bitbucket Cloud, specifically focusing on generative AI in the editor for Pull Request descriptions and comments. It details the steps for workspace admins to activate these features and mentions plans for future editor prompts specific to code and code review.

What this trail covers