The jtk server is a comprehensive Jira Toolkit MCP server for AI agents, providing extensive capabilities across 10 tool categories:
Issue Management: Get, create, update, delete, assign, and transition issues; add/edit/list comments; link issues; manage watchers; view history; move issues between projects; list issue types and link types.
Search: Run JQL queries or quick text searches with pagination and project scoping.
Boards & Sprints: List boards, get board details, list/search/create/update sprints, get sprint issues, backlog, and active sprint, move issues to sprints.
Projects: List, get, and create projects (Scrum, Kanban, etc.); list project statuses.
Users: Get current user, search users by name/email, get user by account ID.
Worklogs: List and add time-tracking worklogs on issues.
Attachments: List, upload, download, and delete issue attachments.
Versions/Releases: List, get, and create project versions with start/release dates.
Dev Info: Get linked branches, pull requests, and commits for any issue via Jira's dev-status API.
Metrics: Get raw status transition history and computed metrics (cycle time, lead time, time in current status, full status breakdown).
It also includes 4 prompt templates (standup summary, sprint status, release notes, dev dependency tree), dynamic permission introspection (only registers tools allowed by your API token), support for both classic and scoped API tokens, and Git-awareness for auto-detecting Jira issue keys from branch names.
Uses Atlassian Cloud APIs and scoped tokens to manage project metadata, user accounts, and permission-based tool visibility.
Features Git awareness to automatically detect Jira issue keys from local branch names, streamlining the context for issue-related commands and tools.
Provides comprehensive management of Jira Cloud resources, including issue CRUD, JQL search, agile boards, sprints, backlogs, worklogs, and development status tracking.
Enables bidirectional conversion between Jira's Atlassian Document Format (ADF) and Markdown for token-efficient responses and better AI agent compatibility.
The most comprehensive dedicated Jira MCP server in the open-source ecosystem. A dual-mode Go binary that works as both a rich CLI tool and an MCP server for AI agents.
11 MCP tools · 4 prompt templates · Full CLI · Single binary · Zero dependencies
jtk | mcp-atlassian (Python) | |
Language | Go (single ~15MB binary) | Python (pip install + deps) |
Jira tools | 11 dedicated tools | ~30 mixed Jira+Confluence |
Startup | ~50ms | ~2s |
Permission introspection | Dynamic at startup | None |
Dev status API | Branches, PRs, commits | Not available |
Issue metrics | Cycle time, lead time, time-in-status | Not available |
MCP prompts | 4 built-in templates | None |
Auth | Classic + scoped tokens | Classic only |
Related MCP server: bbkt
Dual Mode — CLI for humans, MCP server for AI agents, same binary
Git Awareness — Auto-detects Jira issue keys from branch names (e.g., feature/PROJ-123-add-login → PROJ-123)
Dynamic Permission Introspection — Queries /mypermissions at MCP startup, only registers mutation tools your token allows
Dev Status API — Surfaces branches, PRs, and commits linked to any issue via Jira's 3-step dev-status endpoint
Issue Metrics — Cycle time, lead time, time-in-status breakdown with status transition history
MCP Prompts — Standup summary, sprint status, release notes, dev dependency tree
Token-Efficient — Consolidated action-based tools minimize schema overhead. ResponseFlattener strips bloated JSON. Full ADF↔Markdown conversion
Agile-First — Boards, sprints, backlogs, sprint mutations, active sprint detection
# From source
git clone https://github.com/zach-snell/jtk.git && cd jtk
./install.sh # builds and copies to ~/.local/bin
# Or build manually
go build -o jtk ./cmd/jtkPre-built binaries available on the Releases page.
# Authenticate
jtk auth
# Get current issue from git branch
jtk issues get
# Search with JQL
jtk issues search --jql "project = PROJ AND status = 'In Progress'"
# Create an issue
jtk issues create --project PROJ --type Task --summary "Fix login bug"
# Sprint overview
jtk boards list
jtk boards active-sprint --board 1jtk auth Authenticate with Jira Cloud
jtk issues Issue CRUD, search, comments, transitions, links
jtk boards Agile boards, sprints, backlogs
jtk projects List, get, create projects
jtk users Search and get users
jtk versions Project versions/releases
jtk worklogs Time tracking{
"mcpServers": {
"jira": {
"command": "/path/to/jtk",
"args": ["mcp"],
"env": {
"JIRA_DOMAIN": "your-domain",
"JIRA_EMAIL": "you@example.com",
"JIRA_API_TOKEN": "your-api-token"
}
}
}
}jtk mcp --port 8080Variable | Description | Required |
| Atlassian domain (e.g., | Yes |
| Email for the API token | Yes |
| Atlassian API token | Yes |
|
| No |
| Comma-separated tool names to hide | No |
Tool | Actions |
| get, create, update, assign, transition, delete, add_comment, edit_comment, list_comments, list_types, get_links, get_history, link, list_link_types, get_watchers, add_watcher, remove_watcher |
| jql, quick |
| list_boards, get_board, list_sprints, get_sprint_issues, get_backlog, get_active_sprint, search_sprints, create_sprint, update_sprint, move_to_sprint |
| list, get, list_statuses, create |
| get_dev_info |
| list, add |
| list, get, create |
| list, download, upload, delete |
| get_current, search, get |
| get_dates, get_metrics |
Prompt | Description |
| Generate a standup report from recent activity |
| Analyze sprint health and progress |
| Draft release notes from a version's issues |
| Map development dependencies across linked issues |
Three-layer safety model:
Token scopes — Atlassian scopes control which APIs the token can call (403 if missing)
Permission introspection — jtk queries /mypermissions at startup and dynamically hides mutation tools your account lacks
Tool denial — Explicitly hide tools: JIRA_DISABLED_TOOLS="manage_boards,manage_worklogs"
When creating an API token with scopes, prefer classic scopes for full read + write:
read:jira-user,read:jira-work,write:jira-work,manage:jira-project(Read-only: read:jira-user,read:jira-work.) jtk auto-detects the token type, so granular scopes also work — but granular is Beta and finicky: "fat" endpoints require every satellite scope (e.g. /myself needs read:user + read:avatar + read:group + read:application-role), and granular personal API tokens currently return 401 Unauthorized; scope does not match on POST requests through the gateway, making them effectively read-only. jtk auth prints copy-paste scope lists for both.
go test -race ./... # Run tests
golangci-lint run ./... # Lint
go build -o jtk ./cmd/jtk # BuildManage Jira issue attachments (list, download, upload, delete). Actions: 'list', 'download', 'upload', 'delete'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'list', 'download', 'upload', 'delete' | |
| issue_key | No | Jira issue key (for 'list', 'upload') | |
| attachment_id | No | Attachment ID (for 'download', 'delete') | |
| file_path | No | Absolute path to the file to upload (required for upload). Note: paths refer to the MCP server's filesystem. In stdio mode this is the local machine. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description gives minimal behavioral info (list of actions) but lacks details on success/failure, idempotency, permissions, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Short and to the point, but slightly redundant (second sentence restates first). No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a multi-action tool with 4 parameters and no output schema, the description is too brief. Does not explain behavior per action (e.g., what 'list' returns, how 'download' delivers file).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so schema already explains parameters. Description adds no new meaning beyond listing action names already in schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool manages Jira issue attachments with specific actions (list, download, upload, delete). The description distinguishes it from sibling tools like manage_issues or manage_boards.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use each action or alternatives. Does not explain prerequisites or when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage Jira agile boards and sprints. Actions: 'list_boards', 'get_board', 'list_sprints', 'get_sprint_issues', 'get_backlog', 'get_active_sprint', 'search_sprints', 'create_sprint', 'move_to_sprint'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'list_boards', 'get_board', 'list_sprints', 'get_sprint_issues', 'get_backlog', 'get_active_sprint', 'search_sprints', 'create_sprint', 'update_sprint', 'move_to_sprint' | |
| project_key | No | Filter boards by project key (for 'list_boards') | |
| board_id | No | Board ID (for 'get_board', 'list_sprints', 'get_backlog', 'get_active_sprint', 'search_sprints', 'create_sprint') | |
| sprint_id | No | Sprint ID (for 'get_sprint_issues', 'move_to_sprint') | |
| state | No | Sprint state filter: active, future, closed (for 'list_sprints') | |
| query | No | Sprint name search query (for 'search_sprints') | |
| name | No | Sprint name (for 'create_sprint') | |
| start_date | No | Sprint start date ISO 8601 (for 'create_sprint') | |
| end_date | No | Sprint end date ISO 8601 (for 'create_sprint') | |
| goal | No | Sprint goal (for 'create_sprint') | |
| issue_keys | No | Comma-separated issue keys (for 'move_to_sprint') | |
| start_at | No | Pagination start index | |
| max_results | No | Maximum results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose behavioral traits such as destructive actions, permissions needed, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise single sentence with clear list of actions, but could be structured better with section breaks.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, no annotations, and description lacks information about return values or side effects for actions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage; the description adds no additional meaning beyond the schema's parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it manages Jira agile boards and sprints, and lists specific actions, distinguishing it from sibling tools like manage_issues or manage_projects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. alternatives; it simply lists actions without context about when each action is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get development information (branches, PRs, commits) linked to a Jira issue. Actions: 'get_dev_info'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'get_dev_info' | |
| issue_key | Yes | Jira issue key (e.g., PROJ-123) | |
| include_branches | No | Include branches (default: true) | |
| include_pull_requests | No | Include pull requests (default: true) | |
| include_commits | No | Include commits (default: true) | |
| include_builds | No | Include builds (default: true) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It states 'Get' implying a safe read, but does not disclose if the tool is idempotent, what permissions are needed, error behaviors, or rate limits. The description is insufficient to understand side effects or constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief (two sentences) and front-loads the purpose. However, the second sentence ('Actions: get_dev_info') is redundant given the schema and adds little value. It is concise but not optimally informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having 100% schema coverage, the description lacks context about return values, error handling, or preconditions (e.g., issue must exist). Given no output schema and no annotations, the description should provide more completeness to aid the agent, but it does not.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are well-described in the schema. The description adds no additional meaning to parameters beyond what the schema already provides (e.g., action value, issue_key format, boolean flags). It merely restates the action, providing no extra semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves development info (branches, PRs, commits) for a Jira issue. It specifies the exact resource and action, making the purpose distinct from sibling tools like manage_issues. However, it does not explicitly differentiate itself from other manage_* tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The description lacks context about prerequisites, typical use cases, or situations where another tool would be more appropriate. Sibling tools exist, but no comparison is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Unified tool for Jira issue operations. Actions: 'get', 'list_types', 'get_links', 'get_history', 'create', 'update', 'assign', 'transition', 'add_comment', 'edit_comment', 'list_comments', 'delete', 'link', 'list_link_types', 'get_watchers', 'add_watcher', 'remove_watcher', 'move'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'get', 'list_types', 'get_links', 'get_history', 'create', 'update', 'assign', 'transition', 'add_comment', 'edit_comment', 'list_comments', 'delete', 'link', 'list_link_types', 'get_watchers', 'add_watcher', 'remove_watcher', 'move', 'archive', 'unarchive', 'list_transitions', 'add_labels', 'remove_labels' | |
| issue_key | No | Jira issue key (e.g., PROJ-123). Required for most actions | |
| issue_keys | No | Comma-separated issue keys (for 'archive', 'unarchive'). Archiving requires a Jira plan that supports it | |
| project_key | No | Project key (for 'create', 'list_types') | |
| project_id | No | Project ID (for 'list_types' — use project_key or project_id) | |
| summary | No | Issue summary/title (for 'create', 'update') | |
| description | No | Issue description in markdown (for 'create', 'update'). Supports: # headings, **bold**, *italic*, ~~strikethrough~~, [links](url), - bullet lists, 1. numbered lists, > blockquotes, tables, and fenced code blocks. URLs are auto-linked. | |
| issue_type | No | Issue type: Story, Bug, Task, Epic, Sub-task (for 'create') | |
| priority | No | Priority: Highest, High, Medium, Low, Lowest (for 'create', 'update') | |
| assignee_id | No | Assignee account ID (for 'create', 'update', 'assign'). Use 'unassigned' to remove | |
| parent_key | No | Parent/epic issue key. On 'create' sets the parent; on 'update' re-parents the issue (verified by readback - fails loudly if the server ignores it) | |
| labels | No | Comma-separated labels (for 'create', 'update') | |
| components | No | Comma-separated component names (for 'create', 'update') | |
| fix_versions | No | Comma-separated fix version names (for 'create', 'update') | |
| due_date | No | Due date in YYYY-MM-DD format (for 'create', 'update') | |
| transition | No | Target transition name (for 'transition'), e.g. 'In Progress', 'Done' | |
| comment | No | Comment body in markdown (for 'add_comment', 'edit_comment', 'link'). Supports: **bold**, *italic*, ~~strikethrough~~, [links](url), - lists, > blockquotes, and fenced code blocks. URLs are auto-linked. | |
| comment_id | No | Comment ID (required for 'edit_comment') | |
| link_type | No | Link type name (for 'link'), e.g. 'Blocks', 'Duplicate', 'Relates' | |
| inward_key | No | Inward issue key (for 'link') — the issue that IS affected | |
| outward_key | No | Outward issue key (for 'link') — the issue that CAUSES the effect | |
| target_project_key | No | Target project key (for 'move'). Only works with company-managed (classic) projects | |
| target_issue_type | No | Target issue type name (for 'move'), e.g. 'Story', 'Task'. Optional — keeps current type if omitted | |
| start_at | No | Pagination start (for 'list_comments', 'get_history') | |
| max_results | No | Max results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden but merely lists action names without describing behaviors like side effects, idempotency, or error handling. Destructive actions like 'delete' and 'update' lack behavioral context. Some parameter descriptions in schema add transparency, but the main description does not.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one sentence listing actions, very concise and front-loaded with the main purpose. However, it lacks structure such as grouping actions into categories, which would improve usability. No wasted words, but could be better organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (25 parameters, 18 actions, no output schema), the description is strikingly minimal. It does not explain return values, typical usage patterns, or prerequisites. Relies entirely on schema for parameter details, which is insufficient for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the schema already documents all parameters. The main description adds no parameter-specific information beyond listing actions, which are also in the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as for Jira issue operations and lists 18 actions, specifying the resource (issues) and actions. However, it is somewhat a laundry list and lacks a concise purpose statement beyond 'unified tool', slightly reducing clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like manage_search or manage_worklogs. No explicit when-to-use, when-not-to-use, or alternatives. Context from sibling names implies it is for issues, but that is not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get issue lifecycle metrics for dashboards and visualizations. Actions: 'get_dates' (raw date info, status transitions, time-in-status), 'get_metrics' (computed cycle time, lead time, time in current status, status breakdown)
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'get_dates', 'get_metrics' | |
| issue_key | Yes | Jira issue key (e.g., PROJ-123) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must compensate. The description implies read-only behavior ('get') but does not explicitly state that the tool is non-destructive, nor does it mention permissions, rate limits, or other behavioral traits. This leaves gaps for the agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences, front-loaded with the main purpose, and directly lists the actions with meaningful context. No unnecessary words or repetition. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 2 parameters, no output schema, and no annotations, the description covers the actions well but lacks information about return values, behavioral impact, and when to use. It is minimally adequate but leaves room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by explaining the two actions in detail: 'raw date info, status transitions, time-in-status' for get_dates and 'computed cycle time, lead time, time in current status, status breakdown' for get_metrics. This goes beyond the schema's simple enum-like description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get issue lifecycle metrics for dashboards and visualizations.' It specifies two distinct actions with clear explanations, making it easy to understand what the tool does. The resource 'issue lifecycle metrics' is well-defined and distinct from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly indicates usage by detailing actions, but it does not provide explicit guidance on when to use this tool versus alternatives. No when-not-to-use or alternative tools are mentioned. Given the domain separation from siblings, this is adequate but not exceptional.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List and get Jira project details and statuses. Actions: 'list', 'get', 'list_statuses', 'create'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'list', 'get', 'list_statuses', 'create' | |
| project_key | No | Project key or ID (for 'get', 'list_statuses', 'create') | |
| name | No | Project name (required for 'create') | |
| project_type_key | No | Project type: 'software', 'business', 'service_desk' (for 'create', default: 'software') | |
| project_template_key | No | Project template key (for 'create'). Examples: 'com.pyxis.greenhopper.jira:gh-simplified-agility-scrum' for Scrum, 'com.pyxis.greenhopper.jira:gh-simplified-agility-kanban' for Kanban | |
| description | No | Project description (for 'create') | |
| lead_account_id | No | Account ID of the project lead (for 'create'). Use manage_users get_current to find your own. | |
| start_at | No | Pagination start index (for 'list') | |
| max_results | No | Maximum results to return (for 'list') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description lacks behavioral traits beyond listing actions. For a tool that includes 'create' (a mutation), there is no mention of side effects, idempotency, or required permissions. No annotations exist to compensate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with minimal redundancy. However, structuring the actions as a list or grouping related parameters would improve scannability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, but the description does not hint at return values. With nine parameters and multiple actions, it fails to clarify which parameters apply to which action, requiring the agent to infer from schema descriptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All parameters are described in the schema (100% coverage), meeting the baseline. However, the description adds no additional meaning for parameters beyond the action list, missing opportunities to clarify conditional requirements.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it manages Jira projects with four distinct actions: list, get, list_statuses, create. It distinguishes from sibling tools like manage_issues or manage_boards by focusing on project-level operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like manage_issues or manage_versions. The description lists actions but does not explain context or prerequisites for using 'create' versus other actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Jira issues using JQL or quick text search. Actions: 'jql', 'quick'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'jql', 'quick' | |
| jql | No | JQL query string (required for 'jql' action). Example: type=page AND space=DEV AND title~'architecture'. Common JQL patterns: 'project = PROJ AND status = "In Progress"', 'assignee = currentUser() ORDER BY updated DESC', 'labels = bug AND priority in (High, Highest)', 'sprint in openSprints()', 'created >= -7d AND type = Bug', 'text ~ "search term"', 'status changed TO Done AFTER -30d' | |
| text | No | Search text (for 'quick' action) | |
| project_key | No | Optional project key to scope the search | |
| start_at | No | Pagination start index | |
| max_results | No | Maximum results to return (default 20) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It mentions pagination parameters and action types but does not state that the operation is read-only or describe any side effects. For a search tool, this is adequate but could be more explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence followed by a list of actions. It is concise, front-loaded, and contains no unnecessary words. Every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters and no output schema or annotations, the description should cover behavior more thoroughly. It explains the two search modes but does not describe the output format or confirm that it's a read operation. Some essential context is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the baseline is 3. The description adds value by providing example JQL queries and clarifying the action parameter's values, which enhances understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches Jira issues using JQL or quick text search, and lists the two actions. This distinguishes it from sibling tools like manage_issues or manage_projects which are about management, not search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells when to use each action ('jql' vs 'quick') and provides JQL examples. It doesn't explicitly state when not to use this tool, but the context is clear given the sibling tools are for different purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search and get Jira users. Actions: 'get_current', 'search', 'get'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'get_current', 'search', 'get' | |
| query | No | Search query — display name, email, etc. (for 'search') | |
| account_id | No | User account ID (for 'get') | |
| max_results | No | Maximum results to return (for 'search', default 20) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations and the description only lists actions; it does not disclose that the tool is read-only, permissions required, or any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is highly concise and front-loaded with the core purpose; no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite full schema coverage, the description omits return value behavior and does not explain how actions relate to parameters for an agent without output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 4 parameters have descriptions in the schema; the description adds listing of actions but does not provide further semantic value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Search and get Jira users' and enumerates three specific actions, distinguishing it from sibling tools focused on other resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no mention of prerequisites or context where one action is preferred over another.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List and get project versions (releases/fixVersions). Actions: 'list', 'get'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'list', 'get', 'create' | |
| project_key | No | Project key (for 'list', 'create') | |
| version_id | No | Version ID (for 'get') | |
| name | No | Version name (required for 'create') | |
| description | No | Version description (for 'create') | |
| start_date | No | Start date YYYY-MM-DD (for 'create') | |
| release_date | No | Release date YYYY-MM-DD (for 'create') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only lists actions. It fails to disclose behavioral traits like permission requirements, side effects of 'create', or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise in length but incomplete and misleading. A single sentence cannot adequately describe a tool with 7 parameters and multiple actions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and 7 parameters, the description should provide more context about return values, error handling, and action relationships. It is insufficient for effective tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% so description adds minimal value; however, it contradicts the schema by omitting the 'create' action, reducing clarity further.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states only 'list' and 'get' actions, but the input schema includes 'create', creating a misleading inconsistency. The purpose is not fully and accurately conveyed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus sibling tools like manage_issues or manage_projects. No context about prerequisites or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage time tracking worklogs on Jira issues. Actions: 'list', 'add'
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'list', 'add' | |
| issue_key | Yes | Jira issue key (e.g., PROJ-123) | |
| time_spent | No | Time spent (for 'add'), e.g. '2h', '1d', '30m' | |
| started | No | Start datetime ISO 8601 (for 'add'), e.g. '2024-01-15T09:00:00.000+0000'. Defaults to now | |
| comment | No | Worklog comment (for 'add') | |
| start_at | No | Pagination start index (for 'list') | |
| max_results | No | Maximum results to return (for 'list') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It only mentions actions but fails to disclose side effects (e.g., who can add worklogs), permissions needed, or what happens on list (e.g., pagination behavior). Minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences that are front-loaded with purpose and action list. No extraneous information; every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the 7-parameter schema and no output schema, the description is too brief. It does not explain how actions relate to parameters (e.g., time_spent required for add), pagination for list, or default behavior. Incomplete for complex tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the schema already documents individual parameters. The description adds no further meaning beyond listing actions, meeting the baseline for schema-covered parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool manages time tracking worklogs on Jira issues and lists the available actions 'list' and 'add'. This distinguishes it from sibling tools like manage_attachments or manage_issues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool over siblings or which action to choose. It does not mention prerequisites, context, or when to avoid using it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.4.0manage_issues3 fields changedInput schema / properties / action / descriptionPrevious value: -"Action to perform: 'get', 'list_types', 'get_links', 'get_history', 'create', 'update', 'assign', 'transition', 'add_comment', 'edit_comment', 'list_comments', 'delete', 'link', 'list_link_types', 'get_watchers', 'add_watcher', 'remove_watcher', 'move'"New value: +"Action to perform: 'get', 'list_types', 'get_links', 'get_history', 'create', 'update', 'assign', 'transition', 'add_comment', 'edit_comment', 'list_comments', 'delete', 'link', 'list_link_types', 'get_watchers', 'add_watcher', 'remove_watcher', 'move', 'archive', 'unarchive', 'list_transitions', 'add_labels', 'remove_labels'"Input schema / properties / issue_keysAdded value: +{
+ "description": "Comma-separated issue keys (for 'archive', 'unarchive'). Archiving requires a Jira plan that supports it",
+ "type": "string"
+}Input schema / properties / parent_key / descriptionPrevious value: -"Parent issue key (for 'create')"New value: +"Parent/epic issue key. On 'create' sets the parent; on 'update' re-parents the issue (verified by readback - fails loudly if the server ignores it)"v0.1.1manage_attachmentsmanage_boardsmanage_devinfomanage_issuesmanage_metricsmanage_projectsmanage_searchmanage_usersmanage_versionsmanage_worklogsEach tool targets a distinct Jira domain (e.g., attachments, boards, users, issues), with clear descriptions that avoid overlap. An agent can easily distinguish between them.
All tools follow a consistent 'manage_<domain>' pattern in snake_case, providing a uniform and predictable naming convention.
Ten tools is an optimal size for a Jira server, covering major functional areas without being overwhelming or too sparse.
The server covers a comprehensive set of Jira operations: issues, projects, users, boards, worklogs, metrics, versions, attachments, and dev info. No obvious gaps in functionality.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Go MCP server for GitLab: 2 dynamic tools reach 1000+ REST/GraphQL actions. Free/CE, no paid tier.
A MCP server built for developers enabling Git based project management with project and personal…
MCP Server for JFrog, providing tools for development and artifact management.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/zach-snell/jtk'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
