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

🔍 Talk to your backlog — search with full JQL, view issues, list sprint work, all in natural language.
✏️ Create & edit without leaving chat — open tickets, edit fields, transition statuses, assign owners, drop comments.
🏃 Sprint-aware — view sprints, list their work items, spin up new sprints on a board.
🧰 Zero extra auth — rides on the Atlassian CLI (acli) you already log into; nothing new to configure.
⚡ Single static binary — pure Go, runs over stdio, 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.