jira-mcp: Run Your Jira Backlog and Sprints Straight from AI Chat

I spend more time than I'd like translating between an AI assistant and Jira: it suggests a plan, and I go paste it into tickets by hand. The model has the context; it just can't touch the board. So I built jira-mcp: a Model Context Protocol server, written in Go, that lets Claude, Cursor, and any MCP client search issues, run sprints, and create and edit work items, straight from chat.

The pitch is simple: Jira for your AI assistant, with nothing new to authenticate.

What you can do

You talk to your backlog in natural language: search with full JQL, view issues, list sprint work. You create and edit without leaving the chat, so opening tickets, editing fields, transitioning statuses, assigning owners and dropping comments all happen where you already are. It knows about sprints too, and can list their work items or spin up a new one on a board.

There is no extra auth to set up. It rides on the Atlassian CLI (acli) you already log into, so there is nothing new to configure. The whole thing is a single static binary in pure Go that runs over stdio and drops into any MCP client in seconds.

That fourth point is the design decision I'm happiest with. Instead of asking you to mint an API token, store it, and rotate it, the server piggybacks on acli, the official Atlassian CLI. You log in once with the tool Atlassian already ships; jira-mcp inherits the session. No secrets in the repo, none in your MCP config.

The Toolbox

Sixteen tools cover the full loop (read, write, sprints, and project/board navigation):

Tool	Parameters	Description
`jira_auth_status`	-	Check `acli` authentication status
`jira_search`	`jql`, `fields?`, `limit?`	Search work items with JQL
`jira_view`	`key`, `fields?`	View full details of a work item
`jira_create`	`summary`, `project`, `type`, `description?`, `assignee?`, `labels?`, `parent?`	Create a new work item
`jira_edit`	`key`, `summary?`, `description?`, `assignee?`, `labels?`, `type?`	Edit one or more work items
`jira_transition`	`key`, `status`	Transition work items to a new status
`jira_assign`	`key`, `assignee`	Assign work items to a user
`jira_comment_add`	`key`, `body`	Add a comment to a work item
`jira_comment_list`	`key`, `limit?`, `order?`, `paginate?`, `start_date?`	List comments on a work item
`jira_sprint_view`	`id`	View sprint details by ID
`jira_sprint_list_workitems`	`sprint`, `board`, `jql?`, `limit?`, `fields?`	List work items in a sprint
`jira_sprint_create`	`name`, `board`, `start?`, `end?`, `goal?`	Create a new sprint
`jira_project_list`	`limit?`, `recent?`	List visible projects
`jira_project_view`	`key`	View project details
`jira_board_search`	`name?`, `project?`, `type?`, `limit?`	Search for boards
`jira_board_list_sprints`	`id`, `state?`, `limit?`	List sprints for a board

Because jira_search takes raw JQL, the model can answer questions like "what's assigned to me and still open in this sprint?" by composing the query itself, then pipe the results into jira_transition or jira_comment_add without you touching the UI.

Setup

Prerequisites

Install and authenticate the Atlassian CLI:

acli jira auth login

Install

The server is a single Go binary:

go install github.com/artschekoff/jira-mcp/cmd/jira-mcp@latest
# or
git clone https://github.com/artschekoff/jira-mcp.git && cd jira-mcp && make install

Wire it into your MCP client

Add a server entry to your client's MCP config, no env, no token, because acli already holds the session:

{
  "mcpServers": {
    "jira": {
      "command": "jira-mcp"
    }
  }
}

Verify it works:

acli jira auth status

Restart the client and your assistant can start working the board.

Why Ride the CLI Instead of the REST API

I could have wired this straight into Jira's REST API, and inherited token management, scopes, refresh, and a much larger surface to keep secure. Instead it rides on acli, which Atlassian maintains and which already handles auth the way your org expects (SSO, MFA, the lot). The server just translates MCP tool calls into CLI invocations and parses the output back into clean, structured data the model can reason over.

It's the same principle behind my other MCP servers: wrap a mature, trusted tool, expose exactly the operations an agent needs, and keep credentials out of the repo and out of the transcript entirely.

The project is open on GitHub: github.com/artschekoff/jira-mcp, pure Go, runs over stdio. Issues and pull requests welcome.