Summary:At the critical juncture where AI is evolving from "assisted Q&A" to "intelligent collaborator," Atlassian has officially launched Rovo Agents to provide IT and R&D teams with orchestrated, governable, and actionable automated workflows. In this article, Dragonsoft provides an in-depth interpretation of Atlassian's latest release, The Complete Guide to Rovo Agents, systematically breaking down the core architecture of Rovo Agents, design best practices, and pathways for DevOps scenario implementation — helping technical teams build highly reliable AI agents and achieve a substantial leap in R&D efficiency.
Atlassian's Guide to Rovo Agents:
Learn how to build, deploy, and scale your next AI teammates
A practical playbook with blueprints, best practices, and real‑world use cases for adding Rovo Agents into your workflows.
Why Rovo Agents?
Rovo agents are AI teammates that orchestrate work across all your business tools, connecting people, knowledge, and workflows wherever they live.
By automating repetitive tasks and surfacing the right context at the right time, they help teams move faster, stay focused on high‑value work, and deliver better outcomes — no matter which tools are in your stack.
Understanding Rovo Agents: The Building Blocks of Automation
Agents are AI‑driven systems that perform specific tasks by combining instructions, knowledge, skills, and triggers, then are augmented by AI reasoning. In Atlassian's ecosystem, Rovo agents act as orchestrators, automating workflows and delivering outcomes across products. They can be surfaced in chat, invoked in automation, or embedded directly into business processes.
At a high level, Rovo agents are like virtual teammates with a clear role, access to your organization's knowledge, and the ability to take actions on your behalf.
These agents run on top of a shared data layer called Atlassian's Teamwork Graph, which connects your organization's people, work, goals, and knowledge across Jira, Confluence, third‑party tools, and more. This lets them understand and reason over real organizational context, rather than treating each document as an isolated piece of information.
Rovo agents aren't limited only to Atlassian products; they connect to your entire ecosystem via a rich set of 50+ connectors, as well as virtually any application via the Model Context Protocol (MCP). You can automate workflows and orchestrate work across all your favorite tools. With Rovo, your AI teammates have access to the full picture, not just isolated silos.
The Core Components of a Rovo Agent
Every Rovo agent is built from a small set of building blocks:
INSTRUCTIONS | KNOWLEDGE | SKILLS | SCENARIOS AND TRIGGERS
Instructions
The "job description" and operating manual for the agent. Instructions define:
• The agent's role and goals (what it should and shouldn't do)
• The steps it should follow to complete tasks
• The tone and guardrails it should maintain (e.g., precise vs. exploratory)
• In Rovo Studio, this lives in the agent's behavior and scenario instructions.
Knowledge
The data and context that the agent can draw from. This can include:
• Third‑party tools connected to the Teamwork Graph (e.g., SharePoint, Google Drive)
• Atlassian sources like Jira projects and Confluence spaces
• Very specific business rules or templates referenced via Confluence Smart Links
• Knowledge can be broad (all of your Teamwork Graph) or tightly scoped to a domain (e.g., an IT helpdesk KB)
Skills (Actions and Plugins)
The tools the agent can use to read or change the work:
• Reading data: querying Jira issues, looking up customer records, pulling recent tickets
• Taking action: creating or updating Google Docs, Jira issues, drafting Confluence pages, posting to Slack, calling external APIs through Forge/MCP skills, sending a Microsoft Teams message, and sending Google emails
• Skills transform an agent from a passive answer bot into an active teammate that can move work forward
Scenarios and Triggers
To avoid a single, brittle prompt, agents can have multiple scenarios, each representing a specific task to be completed (e.g., "triage feedback," "draft release notes," "write a community post"). Each scenario has:
• Its own instructions, knowledge, and skills.
• A trigger that tells the agent when to use that scenario, based on user intent or event context.
• The default scenario is the fallback path when no other scenario's trigger is matched.
Combined with Rovo's admin and workspace settings, this lets teams deploy agents with clear guardrails; you decide which tools they can connect to, which scenarios are available to which users, and what level of autonomy each agent is granted.
These components are all coordinated by the underlying LLM, which acts as the "brain" of the agent, deciding how to interpret a request, which knowledge to search, which skills to invoke, and which scenario fits best.
Controls, Guardrails, and Governance
Scenarios and triggers also serve as powerful controls over when and how agents run. By tightly scoping each scenario's instructions, knowledge sources, and skills, you can:
• Limit what data the agent can access and which actions it's allowed to take
• Ensure sensitive workflows (such as HR or finance) run only under specific triggers or conditions
• Create separate "read‑only" and "action‑oriented" scenarios so you can phase in automation safely
What Happens When a User Sends a Prompt?
Whether a human types in chat or an automation rule invokes the agent, the flow is broadly the same:
I. Interpret the Request with AI and Context
The LLM reads the prompt, current conversation, and any structured inputs (e.g., issue fields from Jira). It identifies the user's intent and selects the most relevant scenario (or falls back to the default scenario).
II. Decide Which Knowledge and Skills to Use
Based on the scenario's configuration, the agent either:
i. Searches the appropriate knowledge sources (e.g., specific Confluence spaces, Jira projects, or other connected apps).
ii. Chooses which skills to utilize, such as researching related issues, retrieving customer history, or gathering recent feedback.
III. Reason, Orchestrate, and (Optionally) Take Action
The agent then:
i. Synthesizes information from multiple sources using the LLM.
ii. Applies the business rules encoded in its instructions (and any linked templates/rules pages).
iii. Optionally executes actions, such as:
- Creating or updating Jira issues or JPD ideas.
- Drafting or updating Confluence pages.
- Sending notifications via Slack or other tools.
IV. Confirm and Summarize the Outcome
Finally, the agent:
i. Returns a clear, human‑readable summary of what it did and what it recommends next.
ii. Optionally outputs structured data (for example, JSON) so automations can branch on its decisions (e.g., only create new Jira Product Discovery ideas when a piece of feedback represents a genuinely new theme).
In practice, this means Rovo Agents can do far more than answer questions. They can:
• Eliminate repetitive or time‑consuming tasks, such as summarizing meeting notes or grouping hundreds of feedback tickets.
• Solve complex, multi‑step problems, like triaging customer feedback, comparing it to an existing roadmap, and only creating new ideas when needed.
• Improve decision‑making by pulling together context from across your Atlassian and third‑party tools, then presenting it in a way your teams can act on.
By combining instructions, knowledge, skills, and triggers on top of the Teamwork Graph, Rovo agents become the building blocks for reliable, end‑to‑end automation across Atlassian products and beyond.
When to Use Chat, Agents, or Both?
Chat
Chat is best when you need an immediate, ad‑hoc, human‑driven interaction. It's optimized for fast lookups, exploratory questions, clarifications, and one‑off decisions where a human will act on the answer.
• Ideal for quick searches, troubleshooting steps, brainstorming, or clarifying product/process rules on the fly.
• Good when the user expects conversational back‑and‑forth and manual follow‑up (no automatic side effects).
• Low setup cost: no need to configure knowledge scopes, skills, scenarios, or automations.
EXAMPLE:
Ask Rovo Chat, "How do I reset my VPN (Virtual Private Network)?" and instantly receive clear, step‑by‑step instructions or direct links to relevant assets in your knowledge base, so you don't have to search through documentation manually.
Rovo Chat understands common IT support questions and can interpret acronyms like VPN, automatically guiding you to the right troubleshooting steps or support resources.
Agents
Agents are best when work needs to be repeatable, deterministic, multi‑step, or integrated with other systems. They are designed to orchestrate tasks, call skills, and run on schedules or event triggers.
• Use when workflows are 2+ steps, require data aggregation, integration with tools, or must run automatically (scheduled or event‑driven).
• Use when you need structured outputs (e.g., JSON) so automations can branch, loop, and create artifacts deterministically.
• Use when you want a consistent tone/guardrails across multiple related tasks.
EXAMPLE:
By crafting a Rovo Agent to be a feedback triage sidekick, you'll have an AI assistant that continuously scans customer feedback channels (such as support tickets, NPS comments, and community forums), groups related comments into clear themes, checks the existing backlog in JPD (Jira Product Discovery), and automatically creates new idea work items when it finds unmet needs or gaps.
Instead of manually reading, tagging, and de‑duplicating feedback, you can get a prioritized, structured view of what customers are asking for, with direct links back to the original feedback and to the related ideas in Jira Product Discovery (JPD, Atlassian's product for capturing, prioritizing, and managing product ideas).
When to Use Both
There are many cases where Rovo Chat and Agent work together to be most powerful: start with chat for exploration and then transition the validated process to an agent when you need repeatability, automation, or integrations.
• Use chat to prototype prompts, gather examples, and validate the desired output format.
• Once validated, build an agent scenario that uses those instructions, binds knowledge sources, and attaches skills for automation.
• Example workflow: prototype "draft release notes" in chat → convert the prompt to an agent scenario with a trigger + Confluence/Jira skills → schedule it via an automation rule.
DECISION CHECKLIST - "Should I use Rovo Chat or an Agent?"
Is this a one‑time or occasional question? → CHAT
Is the task repeated often or at scale? → AGENT
Does it span multiple steps or systems (Jira, Confluence, third‑party APIs)? → AGENT
Do you need the output in a structured format (JSON) for downstream automation? → AGENT
Do you want it to run automatically on a schedule or event? → AGENT with Jira automations
Do you need exploratory back‑and‑forth or ad hoc human judgment? → CHAT (or hybrid: chat for exploration, agent for production)
If you find yourself repeating the same prompt or process, or if your workflow involves multiple steps, triggers, or integrations, building an agent is the best approach.
Key Considerations for Building Effective Agents
Before you start, clarify the problem you want to solve. Map out the workflow, identify the steps, and look for opportunities to automate or streamline. A focused problem statement and a clear picture of the current process make it much easier to design an agent that delivers reliable value rather than a vague "AI helper."
• Break down complex prompts into manageable scenarios for reliability.
• Define clear instructions, knowledge sources, and required skills for each scenario.
• Use behaviors to set the agent's tone and consistency across scenarios.
• Test and iterate
Finally, make it a point to collaborate with your team since agents can be long‑lived assets that benefit from shared ownership. They can be co‑owned and managed by groups, not just individuals, which means you can distribute responsibility for updates, monitoring, and incident response among team members.
Make sure to document how the agent works, assign clear owners, and encourage teams to contribute new scenarios, examples, and improvements so the agent continues to evolve alongside your workflows.
Best Practices for Agent Design and Prompting
Designing an effective agent starts long before you write the first instruction.
The most successful agents are treated like products: they have a clear purpose, a defined audience, and prompts that are written for reliability, not just creativity. In this section, we'll focus on how to shape your agent's "job description," how to write instructions that are unambiguous and repeatable, and how to use examples, templates, and structured outputs to get consistent results.
Think of these practices as your playbook for turning a powerful underlying model into a dependable virtual teammate that behaves the way your team expects, every time it's invoked.
Define Its Role and Objectives Clearly
Treat this like a job description: what problems is the agent responsible for, what is out of scope, and how will you measure success? A tightly scoped role makes it much easier to design prompts, choose the right data sources, and avoid unexpected behavior.
Write Instructions as If the Agent Has No Prior Context
Be explicit and step‑by‑step. Assume it's someone joining your team on their first day who has never seen your processes before. Spell out the sequence of actions, decision points, and any business rules you'd normally explain to a new hire. The more you remove ambiguity, the more predictable and reliable the agent becomes.
Provide Both Good and Bad Examples
This helps the agent have a framework that can deliver successfully more consistently. Use links to templates or business rules when possible. Just as you'd show a new teammate example tickets, documents, or past work, give the agent concrete samples of what "great" looks like, as well as what to avoid. Include links to Confluence pages, templates, or policy docs and instruct the agent to follow them. These examples serve as a pattern library that the agent can reference, thereby improving quality and consistency across responses.
Use Markdown or Tables for Structured Outputs
Structure is what turns a free‑form answer into something you can reuse and automate. Ask the agent to respond with headings, bullet lists, or fixed table columns so humans can scan quickly and downstream tools can parse results reliably. For more complex workflows, you can even specify simple schemas (for example, named sections or key‑value pairs) that the agent should always follow.
Iterate Based on Real‑World Testing and Feedback
Your first version is just a starting point, not the final product. Watch how people actually use the agent, capture failure cases, and refine the instructions, examples, or knowledge sources over time. Treat each iteration like coaching a teammate: give it clearer guidance, better samples, and updated rules as your processes evolve.
Conversation Starters and Scenario Triggers
While conversation starter examples can help users engage with agents, the focus should be on scenario triggers, which are clear, intent‑driven statements that guide the agent to the right scenario. Think of conversation starters as friendly entry points ("Ask the HR assistant about your benefits") and scenario triggers as the precise cues the agent uses to decide what to do ("Check my PTO balance for this quarter").
Well‑designed scenario triggers reduce ambiguity, improve routing accuracy, and make the agent's behavior more predictable.
Use positive and negative examples to refine triggers. Show the agent (and your team) what a "good" trigger looks like for each scenario, such as a specific, action‑oriented, and tied to a clear outcome, and contrast it with "bad" triggers that are too vague or misaligned.
EXAMPLE:
"Categorize this incoming ticket as incident, service request, or question" is a strong trigger, while "Help with ticket" is not. Over time, you can collect real user queries, label which ones should or shouldn't activate a scenario, and feed those back in as training examples to tighten the mapping.
Avoid using single‑word triggers; instead, provide context‑rich phrases that accurately reflect real user intent. A lone word like "report" or "access" can mean many different things, making it hard for the agent to select the right scenario reliably. Instead, aim for short, natural‑language phrases that encode both action and object, such as "Generate a weekly incident report for my team" or "Request access to the marketing dashboard."
These richer triggers make it easier for the agent to distinguish between similar workflows, reduce misfires, and ensure users quickly land in the experience that actually solves their problem.
Explore Practical Use Cases
Rovo agents are already powering a wide range of workflows, from engineering to HR to product management. They shine wherever work is repetitive, multi‑step, or requires pulling context from multiple tools and turning it into clear, actionable outcomes.
Featured examples include:
Issue Organizer
Automatically review issues in a backlog, group related work, move issues into the right sprints, and assign them to the correct epics or owners. This helps teams keep boards clean and focused without the need for hours of manual grooming.
Release Notes Drafter
Pull details from Jira issues, such as summaries, labels, and fix versions, and turn them into clear, user‑friendly release notes. The agent can propose a first draft that your team can quickly review, edit, and publish to Confluence or share with stakeholders.
Employee Onboarding
Generate tailored onboarding plans that combine HR policies, role‑specific documentation, and team rituals. The agent can assemble checklists, reading lists, and a week‑by‑week plan to help new hires ramp up faster and more consistently.
These are just starting points: once you understand how each use case combines instructions, knowledge, and skills, you can remix them into agents that fit your team's unique workflows.
Craft the Next Great Rovo Agent
Ready to go from zero to hero with Rovo? Start by combining a short, focused learning loop with a small, high‑value build. Learn the core concepts, follow one end‑to‑end example, then ship a simple agent and iterate based on real usage.
Quick Start Project: Build Your First Agent
Build a single, high‑impact agent in 4 steps. Each step is small enough to finish in a day or two.
1: Write a Problem Statement
Write a one‑paragraph problem statement that clearly identifies the user and the specific outcome.
2: Draft a Simple Scenario
Draft a simple scenario with 3–4 behaviors (greet, gather inputs, perform action, confirm).
3: Implement and Test
Implement the scenario in Rovo Studio and run 5 internal tests with colleagues.
4: Release and Iterate
Release to a small pilot group, collect feedback, and iterate.
Begin with a narrowly scoped use case (for example, triaging incoming tickets, summarizing meeting notes, or automating a routine approval).
Narrow scope = faster learning and measurable impact.
Best Practices to Follow
Start simple and measure early
• Keep the first agent to a single primary goal.
• Add telemetry to track usage, success rate, and provide a brief feedback message after each session.
• Use versioned changes so you can roll back quickly.
• Collect one qualitative user quote per week during the pilot to guide prioritization.
Suggested 30/60/90 Day Plan
0–30 Days:
Complete the fundamentals course, watch the video, and post in the hub. Draft your problem statement and scenario.
31–60 Days:
Build the agent in Studio, run tests, and launch a 5–10 user pilot. Collect quantitative and qualitative feedback.
61–90 Days:
Iterate based on feedback, add one additional behavior or knowledge source, and prepare a team rollout plan.
Rovo agents unlock scalable automation when you pair learning with small, real projects. Select one clear problem, follow the steps above, and begin building today to deliver measurable value to your team.
Try Rovo Today
Even though Rovo is still early in its journey, the pattern is already clear:
teams that treat agents like real teammates with clear roles, strong instructions, and tight loops between learning and building see the fastest and most durable impact.
Start small, pick one high‑value workflow, and use the practices in this guide to design an agent that your team can trust and evolve over time.
Translating AI exploration into tangible R&D efficiency relies on rigorous architectural design and scenario accumulation. As an Atlassian Global Platinum Partner, Longzhi provides end-to-end services covering Rovo Agents planning, DevOps scenario customization, cross-toolchain integration, and Agent governance. To obtain a customized AI workflow implementation plan or schedule a demo with our technical architects, contact us today.
Top comments (0)