Skip to main content

AgentGate — Overview

AgentGate lets AI agents read, create, and update Jira issues through a safe, human-approved workflow. Instead of giving agents direct write access to your Jira instance, every proposed change goes through a review step — a human sees what the agent wants to do and approves or rejects it before anything touches Jira.

How It Works​

AI Agent                     AgentGate                     Human Reviewer
   │                            │                               │
   ├── "Create bug ticket" ────►│                               │
   │                            ├── Creates PENDING change ────►│
   │                            │                               │
   │                            │◄── Approves ─────────────────┤
   │                            │                               │
   │                            ├── Applies to Jira             │
   │◄── "Done, created JAI-42" ─┤                               │

The agent can read issues, comments, attachments, and project status — scoped to the Jira projects you choose. Any write operation (creating issues, changing status, adding comments, updating fields) becomes a pending change that requires human approval before it's applied to Jira.

Architecture​

AgentGate has four components. You need the Forge app plus whichever integration method fits your setup.

ComponentWhat it doesWhere to get it
Forge AppBackend that runs inside Atlassian's infrastructure. Handles Jira API calls, manages the approval queue, and provides the Review UI.Atlassian Marketplace
MCP Server (jd-mcp)Exposes AgentGate tools to any MCP-compatible AI client (Claude Desktop, Claude Code, Cursor, Windsurf, etc.). Primary integration method.npm or Docker
CLI (jd)Command-line interface for terminal-based agents, scripting, and CI/CD.npm
Claude Code Plugin (agentgate-claude-plugin)Adds auto-context (runs prime on session start), a /jira skill, and pre-compaction hooks. Optional but recommended for Claude Code users.GitHub
┌─────────────┐
│  jd CLI      │──┐
├─────────────┤  │    ┌──────────────┐      ┌─────────────┐
│  jd-mcp      │──┼───►│  Forge App    │─────►│  Jira Cloud  │
├─────────────┤  │    │  (backend)    │      │             │
│  jd-plugin   │──┘    └──────────────┘      └─────────────┘
└─────────────┘              │
                     ┌───────┴───────┐
                     │  Review UI     │  ← Human approves/rejects
                     │  Token UI      │  ← Admin manages tokens
                     └───────────────┘

Key Features​

Human-in-the-Loop Approval — Every write operation requires explicit human approval. One-click approve/reject in the Review UI built into Jira.

Full Audit Trail — Every proposed change is logged: who proposed it, when, why, and whether it was approved or rejected. Complete accountability for AI actions.

Hierarchical Operations — Create an Epic with all its child Stories in a single proposal. The reviewer sees the whole structure and approves with one click.

Project Context — The prime command gives agents instant project awareness: what's in progress, what's ready to start, what changes are pending review.

Multi-Project Support — Work across multiple Jira projects from a single agent session.

Forge-Native Security — The backend runs entirely within Atlassian's infrastructure. No external servers, no third-party databases. Jira data is exposed to AI agents only through authenticated, scoped API tokens under your control.

Why Not Just Use the Jira API Directly?​

Giving an AI agent a Jira API token with write access means every mistake is immediately permanent. A hallucinated issue, a wrong status transition, or an accidental bulk update goes straight into your project with no undo.

AgentGate adds a safety layer without slowing the agent down. The agent works at full speed — proposing changes as fast as it can think. The human reviewer catches errors before they reach Jira. And because every change is logged, you get a complete audit trail of what the agent proposed, what was approved, and what was rejected.

AgentGate vs Atlassian Rovo MCP Server​

Atlassian offers their own MCP server (Rovo MCP) that connects Jira, Confluence, and other Atlassian products to AI tools. It's included at no additional cost with paid Atlassian plans.

AgentGate takes a different approach:

AgentGateRovo MCP
Write safetyBuilt-in approval workflow — writes are queued for human reviewNo approval gate — writes go directly to Jira
Audit trailPre-execution: proposed → reviewed → approved/rejectedPost-execution: after-the-fact audit logs only
Agent identityChanges tracked to the approving user with full agent audit trailAll changes appear under the user's name, indistinguishable from manual actions
Jira depthAttachments, labels, custom fields, working paginationMissing attachments, labels, custom fields (open GitHub issues)
Platform breadthJira-focusedJira + Confluence + Compass + JSM Ops
Context overheadMinimal (tools loaded on demand)~24,000 tokens at connection

If your priority is broad Atlassian platform coverage, Rovo MCP is the natural choice. If your priority is safe, auditable AI automation of Jira, AgentGate is purpose-built for that.

Both can coexist

AgentGate and Rovo MCP are not mutually exclusive. You can run both MCP servers — use Rovo for Confluence reads and AgentGate for safe Jira writes.

Next Steps​