90,000 tickets auto-classified. Zero wait time. A practical guide to deploying Rovo agents in Jira Service Management for instant resolution and measurable ROI.

The learnings in this white paper are based on the session, “Rovo Agents in action: Accelerating self-service deflection”, presented at Atlassian’s Team ’26 conference. You can check out this session and others on demand.

Service desks across industries share a common challenge: a significant portion of incoming tickets are repetitive, low-complexity requests with known answers. These aren’t just operational inefficiencies; they represent a systemic drain on skilled human resources and a degraded experience for the employees seeking help.

Custom Rovo agents in Jira Service Management change the equation. They take on repetitive tasks and intercept routine requests at the point of need – on the help center, the service portal, or in Slack – resolving them in seconds with intelligence grounded your organization’s actual documentation.

In this paper we dive into the architecture behind these agents, a step-by-step guide to building and deploying them, and a real-world case study from Atlassian’s own IT service desk that proves the math works at scale.

The problem: Repetitive work is crushing service teams

Service leaders are under constant pressure to do more with less, yet capacity is often overwhelmed by routine demand. The volume of repetitive requests is predictable. The answers are documented. Yet the workflow still demands human intervention, every single time.

The hidden cost of known-answer tickets

Every service desk handles a predictable stream of recurring requests: password resets, application access instructions, policy lookups, and misdirected tickets. These are questions with documented answers, yet they still consume agent time, clog queues, and delay resolution for genuinely complex issues.

The numbers tell a stark story:

  • 20 to 60% of tickets that arrive at a service desk have known answers and should never become formal tickets
  • Service agents spend multiple hours each day locating knowledge articles, composing responses, and closing out routine items
  • 59% of agents report fatigue from repeatedly answering the same types of questions
  • Misdirected tickets, such as IT requests landing in HR queues, add additional friction, requiring human agents to manually reroute them

This isn’t just an efficiency problem. It’s a talent problem. When skilled agents spend their days on work that doesn’t require their expertise, organizations lose capacity for the high-judgment, complex issues where human intervention genuinely matters.

What if those tickets never arrived?

Consider the impact if that volume simply disappeared from the queue, not because issues went unresolved, but because they were handled instantly at the point of need, before anyone ever opened the service portal. This is the fundamental promise of AI-first self-service: shifting service management from reactive to proactive.

The solution: Rovo self-service agents

Rovo custom agents operate within Jira Service Management to resolve requests before they become tickets. Rather than waiting for a ticket to arrive and an agent to respond, Rovo agents meet users where they are, on the help center, the service portal, or in Slack, and provide immediate, knowledge-grounded answers.

What this means in practice:

  • Answers in seconds, not hours. No queues, no wait times.
  • Your humans do human-level work. Agents focus on complex, high-value problems.
  • Same quality everywhere. Portal, help center, Slack: one agent, one consistent experience.
  • Your docs, your data, your answers. Grounded in organizational knowledge through the Teamwork Graph, not generic LLM outputs.

Anatomy of a Rovo agent: The five building blocks

Building a Rovo agent requires no coding and can be accomplished in minutes using Rovo Studio. The agent architecture consists of five core components:

1. Identity

Identity defines who the agent is, how it should behave, and what its scope covers. You give the agent a name, assign it a role (IT assistant, HR guide, general help desk agent), and define what’s in scope and out of scope. A well-defined identity creates consistent, predictable behavior. The more explicit the identity, the better the agent performs.

2. Instructions

Instructions are prompts written in plain English that anyone on the team can author. They tell the agent what its job is, when to escalate to a human, and what it should never do, including defining the agent’s tone, whether professional, casual, or empathetic. The more specific the instructions, the more consistent and reliable the agent becomes. A few rounds of testing and refinement are typically sufficient.

3. Knowledge

Knowledge is what the agent knows, and quality matters enormously. You can connect Confluence pages, spaces, folders, external web sources, Google Drive, SharePoint, or other repositories. The critical guidance:

  • Be selective and constrained: Don’t dump an entire Confluence space. Add specific, relevant pages.
  • Create targeted scenarios: Each scenario should have focused knowledge sources
  • Keep knowledge current: If you change a policy, update the source document. Rovo will immediately begin answering based on the updated content.

The principle is simple: garbage in, garbage out. Curated, current knowledge produces accurate, trustworthy responses.

4. Skills

If knowledge is what the agent knows, skills are what it can do. Rovo provides a library of built-in skills, creating tickets, populating fields, routing requests, and organizations can build custom skills using Forge.

The single most important skill for any service agent is “Raise a Request.” This enables the agent to create a ticket in real-time if the user’s question can’t be fully resolved. The agent collects necessary fields, identifies the correct request form, and directs the request to the appropriate desk, closing the loop between self-service and human support.

5. Scenarios (sub-agents)

Scenarios function as specialists within the main agent. Since LLMs perform less reliably with extremely long instruction sets, scenarios allow you to decompose complex workflows into focused, independent units, each with its own knowledge, skills, and instructions.

Think of the main agent as the manager and scenarios as the specialists it delegates to:

  • A scenario dedicated to password resets across multiple systems
  • A scenario for access and permissions requests
  • A scenario that catches misdirected tickets, collects context, and redirects them to the correct desk

Deployment: From build to live in under 30 minutes

Deploying a Rovo self-service agent into Jira Service Management is straightforward:

  1. Navigate to Project Settings within your Jira Service Management space
  2. Click on Channels and Self-Service
  3. Click on Portal
  4. Click Create, test, and go live

We ship a pre-configured template with the “Raise a Request” skill already enabled. All you provide is the relevant knowledge. The full process from build to live on the portal takes under 30 minutes.

Once deployed, the agent operates across all configured surfaces, help center, service portals, and Slack, with no additional per-channel configuration required.

The ticket that never was: How a self-service agent works in practice

Consider a typical interaction: a user visits the service portal and types “I want to install Slack on mobile.”

Behind the scenes, the Rovo agent:

  1. Analyzes the user’s question and determines intent
  2. Searches the associated knowledge base for relevant articles
  3. Retrieves the answer and presents step-by-step instructions within seconds

The issue is resolved. No ticket created. No queue touched. No human involved.

INow imagine the steps didn’t work. The agent shifts to escalation mode:

  1. Captures the full conversation context
  2. Identifies the correct request form
  3. Pre-populates ticket fields based on the conversation
  4. Shows the user what will be submitted for confirmation
  5. Creates the ticket and provides a direct link

Instant resolution when possible. Frictionless handoff when necessary.

Automated ticket classification at scale

Beyond self-service deflection, Rovo custom agents can automate internal service desk operations. The following case study comes directly from Atlassian’s own IT Service Desk (ITSD) team, as presented by Pramanku Chakraborty, a product manager on the Jira Service Management team, at the Team ’26 conference.

The challenge: Bottlenecks before the work even starts

Atlassian’s IT service desk receives thousands of tickets daily. Every one of them must be classified by type, support area, and subcategory before it can be routed and resolved. That meant human agents were spending significant effort just reading ticket summaries, making categorization judgments, and filling in custom fields, all before any actual resolution work could begin.

The agent: Ticket Categorizer Pro

Atlassian’s ITSD team built a custom Rovo agent called Ticket Categorizer Pro with a single purpose: automatically classify every incoming ticket as soon as it’s created. No human guesswork, no delays, and no inconsistency. The agent:

  • Reads the summary and description of each new ticket
  • Classifies it as an issue, a request, or a non-support task
  • Assigns the support area (for example, Account and Access Management)
  • Assigns the subcategory (for example, Access and Permissions)

The agent’s knowledge source is a structured Confluence page that maps ticket characteristics to classification categories. This page includes columns for ticket type, support area, subcategory, and, critically, real examples that help the agent correlate a ticket’s contents with the correct classification. The more explicit and example-rich the knowledge source, the more accurate the classification becomes.

The implementation

  • Custom fields created in Jira Service Management for ticket type, support area, and subcategory
  • A Jira automation rule triggers on every new ticket creation
  • The automation invokes the Rovo agent, which reads the ticket and generates classification values
  • The automation populates the custom fields with the agent’s output
  • A weekly fallback automation catches any tickets that slipped through without classification

The payoff

Ticket Categorizer Pro has automatically classified over 90,000 tickets, saving approximately 200 working days of manual effort. That’s the equivalent of one full-time person’s entire year, handed back to the team.

Human guesswork: eliminated. Classification consistency: standardized across every ticket. Scalability: the system works identically whether 100 or 10,000 tickets arrive.

And that’s just one agent doing one job. Stack a few more across different operations and the math compounds fast.

Getting started: : Start small, measure, expand

  1. Start with a single scenario. Identify the most common, repetitive request type. Build one scenario to handle it.
  2. Curate knowledge carefully. Select specific, high-quality pages rather than broad spaces. Ensure content is current.
  3. Write explicit instructions. Define the agent’s role, scope, escalation triggers, and boundaries clearly.
  4. Include “Raise a Request.” Ensure the agent can create tickets when self-service isn’t sufficient.
  5. Test and iterate. Expect two to three rounds of refinement. Test with real-world queries before going live.
  6. Measure deflection. Track how many tickets the agent resolves without human intervention.
  7. Expand gradually. Once the first scenario succeeds, add scenarios for other common request types.
tooling

Build a self-service culture

Technology alone isn’t sufficient. Organizations that see the greatest impact also invest in changing user behavior, encouraging employees to ask the agent first before raising a ticket. When users experience fast, accurate self-service, adoption follows naturally.

The strategic impact

The implications extend well beyond operational efficiency:

  • Agent capacity is reclaimed. Human agents shift to complex problem-solving and process improvement
  • Employee experience improves. Help-seekers get instant answers without waiting in queues
  • Knowledge quality improves. Maintaining agent knowledge sources drives better documentation practices
  • Scalability becomes inherent. Volume spikes are absorbed without additional headcount

The future doesn’t wait in a queue

AI-powered self-service agents, purpose-built within Jira Service Management, offer a practical, deployable path to eliminating the waste of repetitive, known-answer tickets. The results are measurable: ticket deflection, time savings, and improved satisfaction for both agents and help seekers.

The question for service leaders is no longer whether to adopt AI-powered self-service, but how quickly they can begin.

And self-service is just the beginning. Once the foundational agent is in place, organizations unlock a broader ecosystem of AI-powered automation, spanning ticket classification, knowledge management, and cross-functional workflow orchestration.