Atlassian has announced Code Context, a new feature of Teamwork Graph that allows Rovo and programming agents such as Claude Code, Codex, or Cursor to understand code spread across multiple repositories and connect it with Jira, Confluence, Loom, and other company knowledge sources. The company claims that, in internal tests, agents enriched with this context were 44% more accurate while using 48% fewer tokens, though these are proprietary results and not an independent evaluation.
Key points of Atlassian Code Context in 30 seconds
- Code Context integrates source code from multiple repositories into Atlassian’s Teamwork Graph.
- Claude Code, Codex, and Cursor can access it via the Teamwork Graph CLI from the terminal.
- The agent can link code to Jira tickets, Confluence documentation, Loom videos, and over 50 connectors.
- Atlassian reports achieving 44% higher accuracy and 48% fewer tokens in internal tests.
- The feature is entering open beta with initial support for GitHub and Bitbucket.
This development addresses a key challenge faced by even the most capable programming agents: the model can write good code but still make mistakes because it lacks sufficient knowledge about the system it’s working in.
An agent running on a developer’s laptop typically has the repository open, local files accessible, and context provided by the user. But an enterprise application may be distributed across dozens or hundreds of repositories, services, and teams.
The specific code being modified might depend on a library maintained by another team, respond to an architectural decision documented two years ago in Confluence, or be linked to a Jira ticket conversation.
Atlassian aims for the agent to discover these relationships before it starts writing.
From code search to understanding why the code exists
Code Context creates a queryable representation of the code connected to the Teamwork Graph.
Developers and agents can perform exact searches, natural language queries, and semantic retrieval to locate relevant code across repositories.
The difference from conventional search lies in what surrounds the result.
Suppose an agent receives this request:
Change the authentication system to support the new session policy.
Finding the function that validates a session is relatively straightforward.
The real challenge might be knowing that there’s another service consuming that token, that an implementation was rejected six months ago due to compatibility issues, and that the current ticket is linked to a technical decision documented in Confluence.
That’s where Atlassian tries to leverage Teamwork Graph.
The graph connects people, projects, goals, documentation, and activity from tools like Jira, Confluence, Google Drive, Slack, GitHub, and Salesforce. Atlassian presents it as a dynamic map of the relationships around an organization’s work.
With Code Context, the code itself becomes part of this map.
The agent no longer asks just “Where is this function?”, but also “What depends on it?”, “Why was it built this way?”, or “Which Jira work items are related to this module?”.
Claude Code and Codex can be accessed from the terminal
A particularly interesting aspect for developers and sysadmins is that Atlassian does not limit this context to Rovo.
The company provides Teamwork Graph CLI, a command-line interface designed specifically for external agents to query the graph from the terminal.
Its documentation explicitly mentions compatibility with Claude Code, Codex, Gemini, Cursor, and other agents. After installing the CLI and its skills, the agent can query Jira, Confluence, and other connected sources using natural language.
For example, for Claude Code, the skills are copied into:
~/.claude/skills/
Codex uses the common location:
~/.agents/skills/
Atlassian allows installing or updating these capabilities with:
twg skills install --global
And configuring specifically for Claude with:
twg skills install --global --agent claude
Once set up, the goal is to avoid memorizing hundreds of commands. Developers can ask the agent something like:
Find all context related to PROJ-123, including repositories, PRs, documentation, and dependencies, before proposing changes.
The agent then uses Teamwork Graph CLI to retrieve relevant information.
Now, Code Context extends this capability to include the actual content and structure of repositories.
Fewer tokens because the agent doesn’t have to discover everything
Atlassian accompanies the announcement with two particularly compelling figures.
In its internal benchmarks, agents enriched via Teamwork Graph were 44% more accurate and used 48% fewer tokens than those without this context.
The methodology behind these figures has not been published in enough detail for a universal comparison between agents, so these should be viewed as Atlassian’s internal results.
However, the technical reasoning behind the savings is sound.
When an agent doesn’t know an organization’s relationships, it must reconstruct them.
It can query Jira.
Look for a Confluence page.
Review a repository.
Find out who maintains another service.
Each query consumes tokens, and each retrieved document can potentially become part of the context processed by the model.
Teamwork Graph attempts to do much of that work beforehand.
The company explains that the graph cross-references, links, indexes, and precomputes relationships among billions of objects. Instead of feeding the model large amounts of raw information to discover connections during each request, it can provide a pre-related representation.
Atlassian has been associating this architecture with context savings for months. In May, it reported the same 44% improvement and 48% token reduction for agents using Teamwork Graph, even before adding Code Context specifically.
The economic significance may grow as agents handle longer tasks.
A simple query might consume only a few turns. But an agent modifying a system might explore repositories, read documentation, run tools, review results, and make corrections over dozens or hundreds of steps.
Reducing unnecessary context per step can impact both latency and overall cost.
Code agents face a context problem, not just an intelligence one
The AI programming tools industry has long focused on comparing which model writes better code.
Recent evolution suggests this comparison is increasingly insufficient.
A good model can generate an isolated function correctly but fail when modifying a real application because it doesn’t know decisions made outside the file it is analyzing.
This is even more evident in microservices architectures.
Imagine a change in:
payments-api
which seemingly only modifies a JSON response.
It could also impact:
checkout-service mobile-app-fraud-engine billing-worker analytics-pipeline
If these components reside in five different repositories, an agent that only has payments-api cloned is working with an incomplete view.
Code Context aims to make such multi-repository structures queryable.
The challenge becomes even greater when the reason for a dependency isn’t written in code.
A comment might explain what a function does.
A Jira ticket might clarify why it was implemented this way.
A Confluence page could contain architecture details.
A Loom video might show a design discussion.
An old pull request might document a discarded alternative.
Atlassian’s proposal is precisely to connect these layers.
Authorization matters when the agent can explore the entire enterprise
Providing more context to an agent immediately raises security concerns.
A developer may have permissions to access multiple repositories but not all. The same applies to Jira projects, Confluence pages, or information from other departments.
Code Context preserves the Teamwork Graph’s permission model.
According to Atlassian, authorized users or agents only see information they are permitted to access. This aims to prevent connecting an AI tool from turning the graph into a bypass for existing controls.
Teamwork Graph CLI also incorporates OAuth, audit logs, and scope controls for enterprise use.
This will be especially important as agents move from answering questions to modifying code, creating issues, approving actions, or managing infrastructure.
The correct context isn’t about providing all data but about giving all the data needed and authorized.
GitHub and Bitbucket are the first supported platforms
Code Context is now entering open beta, initially supporting GitHub and Bitbucket.
Organization administrators can check availability through Rovo’s configuration in Atlassian Administration.
Supporting GitHub and Bitbucket covers external repositories as well as Atlassian’s own platform, but Atlassian presents Code Context as a solution for large, multi-repository environments, so future expansion is expected. The current announcement, however, only confirms these two providers.
The company does not intend to replace IDEs or agents.
Code Context acts as a layer of information that these systems can query.
Cursor can remain Cursor.
Claude Code continues operating from its terminal.
Codex maintains its own environment.
Rovo remains Atlassian’s primary strategy.
What changes is that everyone can get a more complete picture of how code fits into the organization’s work.
The new battlefield for agents could be who supplies their context
Atlassian is not alone in addressing this challenge.
Databases, development platforms, cloud providers, and model vendors are all developing mechanisms to give memory and context to agents.
MongoDB aims to bring operational data and vector retrieval close to the agent. GitHub has the entire code history and pull requests. MCP servers are transforming enterprise tools into resources accessible by models.
Atlassian has a unique position since much of the information explaining why things are developed already resides in Jira and Confluence.
Code Context now adds the other half: the software itself.
This helps understand the direction of Teamwork Graph.
Atlassian does not need to create the most powerful programming model on the market if it can make Claude, Codex, Cursor, and others better when working with information managed by its platform.
The company explicitly states in its documentation: it wants any agent to benefit from Teamwork Graph, not just its own.
For development teams, this could be a significant advantage.
In small projects, the developer knows much of the memory system. But in a company with hundreds of services and thousands of employees, that knowledge is spread across repositories, tickets, documentation, and people.
Agents face the same problem as new employees: they can know how to program but still not understand how the company works.
Code Context aims precisely to narrow that gap.
Frequently Asked Questions
What is Atlassian Code Context?
It’s a new feature of Teamwork Graph that incorporates understanding of source code from multiple repositories and enables linking it with information from Jira, Confluence, Loom, and other tools.
Can Code Context be used with Claude Code or Codex?
Yes. Atlassian allows agents like Claude Code, Codex, and Cursor to access Teamwork Graph via Teamwork Graph CLI and use that context before planning, generating, or reviewing code.
How much does it reduce token consumption?
Atlassian states that in internal tests, agents using Teamwork Graph consumed 48% fewer tokens and achieved 44% higher accuracy. These are company-internal figures and not an independent benchmark.
Which repositories does Code Context support?
The open beta starts with support for GitHub and Bitbucket. Administrators can check availability via Rovo’s configuration in Atlassian Administration.
