·

Jira MCP With Cursor

Set up Jira MCP in Cursor so your AI agent can read and update issues, sprints, and boards right from your editor.

Cursor's MCP integration lives under Agent Mode, configured through ~/.cursor/mcp.json (global) or .cursor/mcp.json (project). The value proposition here is narrower than a general-purpose CLI agent but sharper for one specific job: keeping code changes and Jira tickets linked without leaving the editor. This topic covers the setup, the read/write patterns that work inside Cursor's chat panel, automatic ticket linking, and where the integration falls short of a dedicated CLI agent.

Connecting Jira MCP to Cursor Agent Mode

Add the server to .cursor/mcp.json:

{
  "mcpServers": {
    "jira": {
      "command": "uvx",
      "args": ["mcp-atlassian"],
      "env": {
        "JIRA_URL": "https://your-domain.atlassian.net",
        "JIRA_USERNAME": "you@company.com",
        "JIRA_API_TOKEN": "${env:JIRA_API_TOKEN}",
        "JIRA_PROJECTS_FILTER": "PROJ"
      }
    }
  }
}

Open Cursor's Settings → MCP panel to confirm the server registered — it lists connected servers with a green dot and the tool count discovered (mcp-atlassian typically exposes 25-30 tools depending on version and whether Confluence is also enabled). If the server shows red or the tool count is zero, the most common cause is Cursor not inheriting your shell's environment variables — Cursor launches MCP servers from its own process, which doesn't always source your .zshrc or .bashrc.

Fix that by setting the token directly in the env block (acceptable for solo/local use, not for anything checked into a shared repo) or by launching Cursor from a terminal where the variable is already exported:

export JIRA_API_TOKEN="ATATT3xFfGF0..."
open -a Cursor .   # macOS: launch from this shell so the env var is inherited

For project-shared config, keep .cursor/mcp.json checked in with the ${env:VAR} reference, and document in your README that teammates need JIRA_API_TOKEN set before opening the project in Cursor.

Switch to Agent Mode (not Ask or Edit mode — those don't invoke MCP tools) before testing:

[Agent Mode] "Call jira_get_agile_boards and tell me what boards exist for PROJ"

Tips
- If the MCP panel shows the server connected but with zero tools, check whether JIRA_PROJECTS_FILTER or a malformed JIRA_URL is causing the underlying mcp-atlassian process to fail silently on startup — check Cursor's MCP logs panel for stderr output.
- Launch Cursor from a terminal with your environment variables already exported if you're relying on ${env:VAR} interpolation — Cursor's GUI launch (Dock, Spotlight) doesn't always inherit shell environment.
- Confirm you're in Agent Mode before troubleshooting a "tool not found" issue — Ask and Edit modes in Cursor don't have MCP tool access at all, which looks identical to a broken connection at first glance.

Reading and Updating Jira Issues from Within Cursor

Cursor's chat panel handles single-issue lookups and small batch queries well, especially when you're already looking at related code and want quick Jira context without a tab switch.

[Agent Mode] "What's the status and latest comment on PROJ-892?"

Calling jira_get_issue(issue_key="PROJ-892")...

PROJ-892: "NullPointerException in payment webhook handler"
Status: In Progress | Assignee: You | Priority: High
Latest comment (2 hours ago, J. Torres): "Confirmed reproducible with
missing 'currency' field in webhook payload from provider sandbox."

For sprint or board-level queries, the pattern is the same as other clients, though Cursor's chat panel truncates very long tool outputs more aggressively than a terminal would — expect to ask a follow-up for full detail on large result sets rather than getting everything in one response:

[Agent Mode] "List issues in the active sprint on board 42 with status In Review"

project = PROJ AND sprint in openSprints() AND status = "In Review"

Updates work the same way you'd expect, with Cursor surfacing a confirmation step before executing a write tool call — same principle as Claude Code's approval prompts, rendered as an inline "Run tool?" affirmation in the chat panel:

[Agent Mode] "Add a comment to PROJ-892 saying the fix has been pushed
to the payment-webhook-fix branch, and transition it to In Review"

Calling jira_add_comment(issue_key="PROJ-892", body="Fix pushed to
payment-webhook-fix branch, ready for review.")...
Calling jira_get_transitions(issue_key="PROJ-892")...
Calling jira_transition_issue(issue_key="PROJ-892", transition_id="21")...

Tips
- Expect the chat panel to truncate long result sets more aggressively than a terminal — for anything beyond a handful of issues, ask explicitly for a summarized view rather than a full dump.
- Approve write tool calls one at a time rather than batch-approving a session — Cursor's confirmation prompts are there specifically because Jira writes (unlike most code edits) aren't easily undone with Ctrl+Z.
- Keep issue keys visible in your prompt (PROJ-892, not "that ticket I mentioned earlier") — Cursor's context window management can drop earlier conversation turns faster than a dedicated terminal session would.

Linking Code Changes to Jira Tickets Automatically

This is Cursor's strongest Jira MCP use case: because Agent Mode already has your codebase open, it can connect a code change directly to the ticket driving it, in both directions.

From code to ticket — while working on a fix, ask the agent to pull the relevant issue for context without leaving the file:

[Agent Mode, with app/webhooks/payment.py open]

"I'm fixing the NPE described in PROJ-892. Read the issue and its
comments, then look at this file and tell me if the missing 'currency'
field case is handled anywhere upstream."

From ticket to commit — once a fix is ready, have the agent draft a commit message and PR description that references the ticket, then update Jira with the actual commit reference:

[Agent Mode] "I've committed the fix for PROJ-892 as commit a3f9c21.
Add a comment to PROJ-892 linking that commit, and transition the
issue to In Review."

Calling jira_add_comment(issue_key="PROJ-892",
  body="Fix committed: a3f9c21 (payment-webhook-fix branch). Ready for review.")...
Calling jira_transition_issue(issue_key="PROJ-892", transition_id="21")...

For teams using conventional commits with a ticket-key prefix (PROJ-892: fix NPE in webhook handler), you can ask Cursor to enforce that convention automatically when generating commit messages, closing the loop without a separate step:

[Agent Mode] "Draft a commit message for the currently staged changes,
using conventional commit format prefixed with the Jira ticket key PROJ-892"

PROJ-892: fix null pointer exception in payment webhook handler

Guard against missing 'currency' field in webhook payload from
provider sandbox environment. Adds validation before deserializing
the payment amount object.

This two-way linking — pulling ticket context into the code, and pushing commit references back into the ticket — is the workflow Cursor handles more smoothly than a pure CLI agent, precisely because it never loses the open-file context mid-conversation.

Tips
- Reference the exact commit SHA when asking the agent to update Jira — "the fix I just made" is ambiguous once you've made several commits in a session; a SHA is not.
- Standardize your commit message convention (ticket key prefix) and have the agent enforce it consistently — this is a small habit that makes a Jira ticket's linked commits trivially easy to audit later.
- Don't rely on Cursor to auto-detect which ticket a code change relates to — always name the issue key explicitly; the model has no reliable way to infer it from code alone.

Known Limitations in Cursor's Jira MCP Integration

  • No dedicated Jira-specific UI. Everything happens through the general Agent Mode chat panel — there's no Jira issue browser, board view, or JQL builder inside Cursor itself. For genuinely complex JQL exploration, you'll still open Jira's web UI or use a terminal-based client with better output formatting.
  • Environment variable inheritance is inconsistent. As covered above, Cursor launched from a GUI (Dock, Spotlight, Finder) doesn't reliably inherit shell-exported environment variables on macOS — this trips up more people than any other part of the setup.
  • Chat panel truncation on large result sets. Sprint reports or broad JQL searches returning 30+ issues get summarized or cut short more aggressively than in a terminal client, which can hide relevant issues if you're not careful to ask for pagination or explicit counts.
  • No batch-approval controls. Unlike Claude Code's .claude/settings.json permission allowlists, Cursor as of the current release doesn't offer fine-grained, persistent tool-level auto-approval for MCP servers — every write requires an in-session confirmation, which is safer but slower for repetitive bulk operations.
  • Sprint mutation tools inherit the same mcp-atlassian constraint as every other client: jira_create_sprint and jira_update_sprint are unreliable against team-managed boards. This isn't Cursor-specific, but worth restating since it's easy to assume a different client behaves differently.

Tips
- For heavy JQL exploration or large sprint reports, do the query in a terminal-based client or Jira's own UI, then bring the specific issue keys into Cursor for code-linked work — play to each tool's strengths.
- Launch Cursor from a terminal (not Dock/Spotlight) whenever you're relying on ${env:VAR} config to avoid the most common "server connected, zero tools" support case.
- For bulk operations (triage, batch labeling), prefer Claude Code or Gemini CLI where you can pre-approve read tools and review a full batch before confirming — Cursor's per-call confirmation model makes large batches tedious.

Tips

Cursor's Jira MCP integration is purpose-built for the moment you're heads-down in code and need ticket context without breaking flow — it's not the tool to reach for when you need heavy JQL reporting or bulk backlog operations.

Tips
- Use Cursor for the code-to-ticket and ticket-to-commit linking workflows where its open-file context gives it a real edge over a standalone CLI.
- Verify environment variable inheritance first if the server shows connected with zero tools — it's the most common setup failure on macOS specifically.
- Reach for a terminal-based Jira MCP client for heavy reporting, bulk triage, or anything needing pre-approved batch writes — Cursor's confirmation-per-call model isn't built for that scale.

Next Real World Workflow Sprint Planning And Bug Triage