The Atlassian MCP server control model, explained
The Atlassian Rovo MCP server is hosted by Atlassian at https://mcp.atlassian.com/v1/mcp (an authv2 variant is recommended). It launched in 2025, is now generally available, and covers Jira, Confluence, Jira Service Management, Bitbucket Cloud, and Compass. That is about 55 tools per the supported-tools list, organized into read, write, and search permission groups per product.
Compare it with Notion. Both vendors built their controls around connections, not calls. Atlassian’s version is stronger: allowlists that block, an IP check on every call, and an audit log of individual tool invocations. It is one of only three per-call audit logs in the series, with Slack and Zapier.
Sources: the understand, control settings, and monitor activity docs, plus the official repo.
This page covers the server’s own controls. For the cross-server picture, see the MCP server controls comparison. For what a control layer adds on top, see the coverage matrix.
What’s at stake
The write side is the org’s system of record for work. An agent can create and update Jira issues, write Confluence pages, act on service-desk requests, and touch Bitbucket. If it can edit the ticket queue and the wiki, it can change what the organization believes about its own state.
The bigger risk is on the read side. Jira Service Management is an external-input surface. Service-desk tickets come from outside the org, because that is their job. Any agent wired to JSM tools reads untrusted text as routine work. Every server in this series has an injection story. Here the carrier arrives through the front door, addressed to the team, with a ticket number.
Auth and permission mirroring
There are two ways to authenticate. OAuth 2.1 is the default, and users link AI tools through a consent screen. API tokens are for headless, service-style clients, and an org admin has to enable them. Coverage differs by path. Per the repo docs, JSM and Bitbucket tools work only with an API token, and Compass only with OAuth.
Under both sits permission mirroring. In Atlassian’s words, “Access is scoped to the user’s existing permissions in Atlassian.” MCP clients act “with your existing permissions” in Jira, Confluence, and Compass.
Atlassian enforces this on its side, like GitHub’s token scope and Notion’s permission system. The agent can’t configure its way past it. The catch is the same too: the limit is whatever the connecting user can see, and for most users that is a lot.
The admin controls
These all live in Atlassian Administration, outside the agent’s reach. Notion’s Enterprise plane has that property too, with fewer mechanisms.
- Domain allowlist. Org admins control which AI tools may connect over OAuth. Atlassian-supported partner domains (Anthropic and OpenAI among them) are allowed by default. They can be blocked, but only as a set: “You cannot block individual domains” within it. Admins add or delete custom trusted domains one at a time. The docs state that domain blocking applies to OAuth only, so API-token tools bypass the allowlist entirely.
- API-token toggle. An org-level switch turns token auth off, which closes the path that skips the domain check.
- IP allowlisting, checked per tool call. The org’s IP allowlist isn’t only a connect-time check. Requests are evaluated against it on each tool call. It is the only per-call decision any server in this series makes natively. It decides a network property: where the call comes from, never what the call does.
- Permission groups. Tools group by intent, such as
read_jira,write_confluence, andsearch_atlassian. Per the repo docs, “Organization admins grant or revoke access at the permission-group level,” and each tool inherits its group’s access. Revoke the write groups and you have an org-wide read-only setup. The grain is about a dozen switches, org-wide, with no per-tool selection and no per-connection variant. - Revocation. The MCP app appears in Connected apps after first consent. Site and org admins can review or revoke it there, and users can revoke their own grants.
This is the most complete answer any vendor in the series gives to “who may connect, from where, with which product surfaces.” Notion’s plane answers a subset of those questions on its Enterprise tier. Atlassian answers them across tiers, adds the per-call IP check, and backs it with the audit log below.
The audit log
Per Atlassian’s monitoring docs, an event is recorded “every time a tool is used through the Atlassian Rovo MCP server.” Each entry “includes the tool name, action, and user who performed it.” You query it in Atlassian Administration under Insights, then Audit log, filtered as “Rovo MCP User Actions,” with ALQL for advanced search.
Most servers in our comparison write no admin-queryable call-level record. This is one of three that do. Slack (Enterprise Grid only) and Zapier are the others. When something goes wrong, an admin can answer “which tools fired, as whom” from the vendor’s own console. Atlassian deserves credit for shipping that.
It has limits, and they match the general audit gap:
- It’s a record, not a rule. Nothing reads the log before the call, and nothing can hold a call based on it. The invocation is written down after it happens.
- Arguments aren’t part of the stated record. You get tool name, action, and user, not what the tool was asked to do. “write_jira fired” is in the log. The payload isn’t stated to be.
- Attribution thins on the token path. API-token calls log as the token’s service account, “rather than individual end users in the AI tool.” That is one identity for every user of a headless integration. OAuth has its own caveat: additional users authorizing an already-installed app don’t appear.
- It’s one vendor’s silo. The record lives in Atlassian’s console and covers Atlassian’s surface. An agent that reads a poisoned ticket here and acts through another server leaves the log at the moment that matters most.
What’s missing
- No per-connection read-only. Permission groups give a coarse org-wide version. Nothing lets one agent be read-only while another writes.
- No per-tool filtering. The grain stops at the group.
- No approvals. Nothing holds a write for a human. The docs advise users to “review high-impact changes before confirming,” which is guidance to the person, not a mechanism in the server.
- No per-call policy. Apart from the IP check, every control decides which clients connect, not which calls are allowed. An allowed client, on an allowed IP, in an allowed permission group, can make any call those grants cover. The audit log will record it.
Injection: the ticket is the payload
The reference incident is a proof of concept, so we describe it as one. In 2025, Cato Networks demonstrated a technique it called “Living off AI” against Atlassian’s MCP server. An external attacker files a support ticket with a hidden prompt injection. An internal engineer processes it with MCP-connected tooling. The agent acts on the injected instructions with internal privileges.
Per the reporting (citing Infosecurity Magazine, June 2025), this worked “without any direct access to the MCP server,” and the “support engineer effectively becomes an unknowing proxy.” Atlassian’s own repo docs say LLM clients are vulnerable to prompt and indirect injection.
Look at what the admin controls do against this chain. The ticket passes the domain allowlist, because the client is approved. It passes the IP check, because the engineer’s IP is fine. It passes permission mirroring, because the engineer has the permissions. The audit log records the resulting calls, attributed to the engineer. Every control holds and the incident happens anyway, because none of them work at the level of the attack.
Where the native model ends
Atlassian has the series’ best connection-level controls (allowlists, a per-call IP check, group-level reduction, revocation) and one of its three per-call audit trails. What nothing does is decide a call. There is no approval hold, no condition on a write that follows an untrusted read, and no policy that tells one write_jira call from another. The audit trail that does exist is a per-vendor silo, accurate about Atlassian and blind one server over.
What to do now:
- Keep the domain allowlist deliberate.
- Disable API tokens unless a headless integration needs them, and give that integration a least-privilege service account, since the log will show the account, not the user.
- Revoke write permission groups your agents don’t need.
- Treat every JSM-connected agent as reading attacker-supplied text, because it is.
Then add the parts no vendor console holds: a hold on writes, a per-minute call ceiling, and a record that follows the agent across servers. ACP does this with a hook in your agent’s harness that sends each tool call to a gateway. The policy and the record sit outside the agent’s process. The hook itself is harness configuration, so pin it with managed settings on machines you don’t trust. On this surface that layer finishes what Atlassian’s admin controls start.
Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex