Atlassian Breaks Down Enterprise-Grade AI Coding Agents: A Full-Lifecycle Automation Deep Dive

At a workshop at the AI Engineers World's Fair, Atlassian's Andy Wong, Shane Wolfe, and Andrew Bocan laid out their enterprise-grade AI coding agent strategy from the past year and a half. Their core thesis is clear: as AI coding tools proliferate, the productivity gains from any single tool are slowing, and the real opportunity lies on the "left and right sides" of code—planning, orchestration, review, and operations.

Why the Focus Shifted from "Writing Code" to "Beyond Code"

Andy Wong opened with an observation: there are more and more AI coding tools, but the marginal productivity gain from each one is narrowing. Atlassian has therefore bet on the less conspicuous parts of the software development lifecycle—planning, orchestration, code review, and operations.

Around this thesis, Atlassian built a product matrix: Teamwork Graph, AI Planner, AI AutoDev, AI Reviewer, AI SRE, and at the center of all of them, the AI Context Engine. The logic is that the bottleneck in enterprise R&D often isn't typing code itself, but the fact that context is scattered across Jira tickets, Confluence documents, Slack messages, and code repositories.

According to the live demo, this system has already been deployed with Jira Coding Agent (JCA) as its entry point, and JCA is now generally available.

Jira Coding Agent: Turning Tickets into Reviewable PRs

Jira Coding Agent is Atlassian's native coding agent, and its standout feature is "deep enterprise context." It reads Jira tickets and Confluence documents, and also searches email and Slack messages to gather the background needed to complete a ticket. Developers can interact with Pull Requests directly within the Jira ecosystem, or assign tasks to their preferred third-party agents, such as Claude, Cursor, or Codex.

For verification, JCA relies on the acceptance criteria checklist in the ticket. The agent runs in a fully sandboxed environment—container-based, Docker-enabled—where it can install dependencies, run the project, and even execute verification steps in a browser. As long as the repository clearly documents "how to run," it can complete acceptance checks on its own.

On model selection, JCA currently supports Anthropic and OpenAI model families, uses a credits-based billing model, and also supports bring-your-own API keys. When asked on stage whether they do intelligent model routing, the team admitted they don't yet, but AutoDev is moving in that direction—hoping to help teams determine whether a task is "Haiku-level" and provide metrics to justify it.

Pull Request (PR) is a core mechanism in code collaboration platforms (such as GitHub, GitLab, and Bitbucket): when a developer submits a set of code changes to a repository, they open a merge request. In the PR workflow, team members can review changes line by line, leave comments, request modifications, and automatically run tests and checks through CI pipelines, ultimately having someone with the right permissions approve and merge. For AI coding agents, the PR is a natural "human-machine interface": the agent makes code changes in a sandbox and submits them as a PR, so humans only need to review the diff and whether acceptance criteria are met, without worrying about the agent's internal execution process. PRs also record review comments, status checks, and merge history as traceable metadata, making them an important data source for measuring agent output quality and ROI.

AI Reviewer: Filtering Low-Value Comments with Self-Trained Models

Code review is an area where Atlassian has invested heavily. AI Reviewer's goal isn't just to find bugs, but to make an overall judgment on whether a PR meets requirements by combining context from Jira, Confluence, SCM, and Slack.

One noteworthy detail: the team found that many code review tools are overly nitpicky, generating large volumes of low-value comments. Atlassian chose to self-train models to filter out this noise, and the figure shared on stage was a comment resolution rate of about 40%, close to the human baseline of 45%. This number suggests AI review is approaching the usable threshold, but still has a way to go before fully replacing humans.

There's also a companion feature for centrally managed Standards. Teams can create standards and write rules in Rovo Dev, and specify which repositories they apply to (via manual selection or pattern matching), covering SCM platforms like GitHub, GitLab, and Bitbucket Cloud. The live demo showed the process of creating a "design token enforcement" standard: fill in the name, description, and rules, select target repositories, and then the coding agent automatically checks compliance during the PR workflow.

Self-trained model in this context refers to a model that Atlassian fine-tunes or trains specifically on its own code review data (historical PR comments, resolution status, human feedback, etc.), rather than directly calling a general-purpose LLM. General models tend to try to "cover everything," commenting even on trivial details like naming style and comment formatting, which creates excessive noise and review fatigue among developers. A self-trained model can learn an organization's internal review preferences and "what counts as a valuable comment," thereby filtering low-value feedback at generation time or in post-processing. The cost is ongoing data labeling and model maintenance; the benefit is a higher comment resolution rate and a lower false-positive rate—the ~40% resolution rate mentioned in the article shows that this targeted training has already produced results approaching the human baseline.

AutoDev: Picking Up Tasks Autonomously from the Backlog—But Controlling the "Flood of Work"

AutoDev is Atlassian's attempt at AI SDLC orchestration. Its initial version scans the Jira backlog, picks out work items the agent is confident it can complete autonomously, and directly generates PRs for the team to review.

Andrew Bocan, who leads AutoDev, emphasized several real-world constraints. First is requirement completeness: many tickets in the backlog have only a one-line summary, and the agent can't determine the goal—in which case it pulls in a human to fill in the spec. Second is the review bottleneck—"review is where things die"—so AutoDev uses Slack to remind the right people at the right time. Third is workflow control: teams can configure how many PRs are allocated per person per week, the maximum credits to use per month, and which repositories are enabled.

Andrew also mentioned an easily overlooked point: nobody wants to review 50 PRs a day. So AutoDev's design philosophy is to advance gradually rather than dumping a large batch of changes on the team all at once. For large-scale organizational migrations (like Rails version upgrades or similar changes across tens of thousands of services), this "agents do the work, humans coordinate" model is seen as the main opportunity.

AI Context Engine: Making Product Repositories "Feel Like a Monorepo"

Throughout the talk, "context" was the most frequently used word. Atlassian has about 15,000 repositories internally, and answering questions like "where should this change be implemented" or "which services depend on this service" is extremely difficult.

The Context Engine's approach is to narrow the search space: first locate the code region most likely to contain the answer, then dig deeper, while overlaying document information from Teamwork Graph. Shane Wolfe pointed out that documentation is often outdated, but it records "why the decision was made at the time," which is valuable for avoiding repeating historical mistakes. Code is the truth of the present; documentation is the decision context of the past—only by combining both can you support better implementation-path planning.

An interesting judgment: the team believes many organizations have historically chosen monorepos to provide context to agents, but this brings monorepo debt and significant tooling costs. The Context Engine aims to make ordinary product repositories "feel like a monorepo"—through on-demand, high-speed code-level retrieval.

On the question of context conflicts and authority, Atlassian's strategy is to avoid snapshot caching so information doesn't go stale, while deferring "authority" to human-in-the-loop confirmation. The "verified" badge in Confluence is one example—it marks documents that are still valid so they're prioritized in retrieval.

Monorepo refers to managing multiple projects, services, or packages in a single code repository—Google, Meta, and others are typical examples. Its advantages are that cross-project dependencies, search, and refactoring are extremely convenient, and agents can see the full code context at once; the downside is that the repository becomes enormous, build and permission management are complex, and significant in-house tooling (such as incremental builds, code indexing, and sparse checkout) is needed to maintain efficiency. Many organizations consider migrating to a monorepo to give AI agents complete context, but underestimate the tooling debt that comes with it. Atlassian's Context Engine attempts to simulate the monorepo retrieval experience with "on-demand, high-speed code-level retrieval": the agent first narrows the candidate range, then drills into specific files, gaining sufficient context without changing the repository structure.

AI Planner and AI SRE: Covering Both Planning and Operations

AI Planner focuses on feasibility assessment and task breakdown. After a developer or manager provides an idea, Planner uses the Context Engine to determine whether it's feasible in the current repository and provides an implementation plan with multiple execution paths.

AI SRE targets the 2-3 a.m. incident diagnosis scenario. It extracts context from historical incidents, performs root cause analysis, suggests possible fixes, and integrates with Slack to provide quick summaries—including whether multiple external customers are affected or only a small subset of users.

The live demo also showed a combined workflow: use JCA to break an epic into smaller Jira tasks, then trigger JCA sessions through automation rules so the agent autonomously develops each subtask. The team said this pattern can be extended further—breaking a story into multiple epics (base version, V0, V1, V2) and refining layer by layer—with no technical obstacles.

SRE (Site Reliability Engineering) is an operations methodology originating at Google that emphasizes using software engineering practices to ensure system reliability, with core practices including service level objectives (SLOs), error budgets, postmortems, and automated incident response. AI SRE refers to bringing LLMs and agents into this process: during incidents, quickly aggregating alerts, logs, historical events, and change records to help locate root causes and suggest fixes; in daily operations, extracting patterns from historical incidents to help teams prevent recurring failures. The 2-3 a.m. incident diagnosis scenario in the article is a typical SRE pain point—information is scattered and time pressure is high—and agents can search multiple systems simultaneously and provide key judgments in Slack such as "whether external customers are affected," shortening mean time to recovery (MTTR).

Takeaways for Enterprise Adoption

The value of this talk isn't in listing features, but in exposing the real constraints of deploying enterprise-grade agents. Cost control (credit limits, per-ticket or per-week budgets) has become table stakes; workflow control (per-person weekly PR limits) is a necessary design to prevent agents from creating a review flood; and human-in-the-loop isn't a compromise—it's a mechanism for handling requirement ambiguity and context authority.

Another signal worth noting is ROI measurement. Atlassian has built dashboards for each tool, tracking metadata such as review counts, agent run volume, and the number of PRs generated by AutoDev. When agents can potentially "burn a billion tokens in some corner," observability is no longer a nice-to-have.

As for the recurring Wi-Fi failures during the session, they became an unintended footnote: on the road to AGI, the first thing to solve is the network connection.