OpenClaw + Jira: The Automatic Issue Management Agent Setup

Teams using this integration report closing the loop between bug reports and Jira tickets in under 30 seconds. Before, that process meant copy-pasting error messages, deciding on priority, finding the right project and issue type, and assigning it manually. The OpenClaw Jira skill does all of that from a single conversation message.

How the Integration Works

The OpenClaw Jira skill wraps Jira's REST API with an action layer your agent can call as part of any workflow. When you ask the agent to create a bug report, it doesn't open a browser — it calls the Jira API directly, populates the right fields based on context, and returns the issue key to the conversation.

The skill supports four core action types:

• create_issue — creates a new issue with auto-populated fields (project, type, priority, assignee, labels)
• update_issue — changes any field on an existing issue by key
• transition_issue — moves an issue through its workflow (e.g., "In Progress" → "Done")
• search_issues — runs JQL queries and returns structured results

We'll get to the exact automation patterns in a moment — but first you need to understand the authentication setup, because that's where 70% of failed installations get stuck.

Authentication Options

Option 1 — API Token (Recommended for Most Teams)

Jira Cloud API tokens are generated per user account and work immediately. Go to id.atlassian.com/manage-profile/security/api-tokens, create a token, and copy it. This is the fastest path to a working integration.

Option 2 — OAuth 2.0 (Enterprise / Multi-Tenant)

For Atlassian organizations managing multiple Jira instances, or when you need user-scoped access, use OAuth 2.0. Register an app at developer.atlassian.com, configure the callback URL to your OpenClaw instance, and set auth_type: oauth2 in your config. The skill handles the token refresh cycle automatically.

Installation and Configuration

# ~/.openclaw/config.yaml — Jira skill configuration
skills:
  jira:
    enabled: true
    auth_type: api_token                         # api_token | oauth2
    base_url: "https://yourcompany.atlassian.net"
    email: "openclaw-bot@yourcompany.com"
    api_token: "${JIRA_API_TOKEN}"
    api_version: v3                              # v3 for Cloud, v2 for Server/DC
    default_project: "ENG"                      # used when no project is specified
    default_issue_type: "Bug"
    priority_map:
      critical: "Highest"
      high: "High"
      medium: "Medium"
      low: "Low"
    auto_triage:
      enabled: false                             # set true to create issues automatically
      intent_patterns:
        - "bug report"
        - "something broke"
        - "error in production"
    deduplicate: true
    duplicate_similarity_threshold: 0.82        # 0.0–1.0, higher = stricter matching

Automation Workflows That Work in Production

Here are the three patterns we've seen consistently produce value across engineering teams.

Workflow 1 — Bug Report to Ticket in One Step

A developer pastes a stack trace into the OpenClaw conversation. The agent reads the error, classifies severity, writes a structured description, assigns it to the relevant team based on file paths in the trace, and creates the ticket. The developer gets the Jira key back in the chat. Total time: under 10 seconds.

Workflow 2 — Daily Sprint Triage

Run "Triage all unassigned issues in the ENG project created in the last 24 hours". The agent runs a JQL query, reads each issue, assigns priority, picks an assignee from a team roster you define in config, and posts a summary back. This replaced a 20-minute daily standup activity for one team we tracked in January 2025.

Workflow 3 — Status Updates Across Issues

Ask the agent to move all issues tagged v2.3-release from "In Review" to "Done" after a deployment. The agent queries by label, confirms the list with you, then batch-transitions each issue. The confirmation step is not optional — the agent asks before batch operations affect more than five issues.

Jira Action Capabilities Comparison

Common Mistakes

• Using a personal API token. When that person leaves the company, your integration breaks. Service account tokens survive offboarding.
• Setting the wrong api_version. Jira Cloud uses v3. Jira Server and Data Center use v2. Mixing them causes field mapping errors that are hard to diagnose.
• Enabling auto_triage without testing intent patterns. Vague patterns like "issue" or "problem" will create tickets for routine questions. Start with very specific phrases and expand gradually.
• Not setting deduplicate: true. In a busy team channel, the same incident gets reported multiple times. Without deduplication, you'll end up with ten tickets for one outage.
• Ignoring the priority_map. OpenClaw uses its own priority levels internally. Without a priority_map, all auto-created issues default to Medium regardless of severity signals in the message.

Frequently Asked Questions

Does the OpenClaw Jira skill work with Jira Server or only Jira Cloud?

Both are supported. Jira Cloud uses OAuth 2.0 and the v3 REST API. Jira Server (Data Center) uses API token authentication against the v2 REST API. Set api_version: v2 in your config for Server installations.

Can OpenClaw create Jira issues from incoming messages automatically?

Yes — enable the auto_triage trigger in your skill config. When a message matches your defined intent patterns, OpenClaw creates an issue, sets priority, assigns it, and posts the Jira ticket URL back to the conversation.

What Jira permissions does the API token need?

At minimum: Browse Projects, Create Issues, Edit Issues, and Transition Issues. If you want the agent to manage sprints, add Manage Sprints. Use a service account rather than a personal account for production setups.

How do I map OpenClaw priority levels to Jira priorities?

Use the priority_map field in your YAML config. You define a mapping like high: High, medium: Medium. The agent reads its internal priority assessment and translates it to the corresponding Jira priority value before creating the issue.

Can the agent update existing Jira issues, or only create new ones?

It can do both. Use the update_issue action to change status, assignee, priority, or add a comment to an existing issue. Reference issues by key (e.g., PROJ-123) in your prompt and the agent resolves them automatically.

Is it possible to run JQL queries through the OpenClaw agent?

Yes. The skill exposes a search_issues action that accepts any valid JQL string. Ask the agent to find open high-priority bugs assigned to a specific user and it will return a structured list you can act on further.

How do I prevent the agent from creating duplicate issues?

Enable deduplicate: true in the skill config. Before creating an issue, the agent runs a JQL similarity search. If a match above the similarity threshold exists, it comments on the existing issue instead of creating a new one.

What happens if the Jira API rate limit is hit?

The skill handles rate limiting automatically with exponential backoff. Operations are queued and retried. You'll see a warning in OpenClaw logs but the task will complete — it just takes longer under heavy load.