Building Custom AI Agents for Team Workflows

Atlassian’s Rovo AI platform comes with several out-of-the-box agents (like the Brainstorm Facilitator and Workflow Builder) that help teams work smarter. But what if your team has a unique process that no default bot quite fits? This is where custom Rovo agents come in. A custom Rovo agent is essentially a tailored AI teammate, an AI bot trained or configured to perform certain tasks or answer domain-specific questions within your Jira and Confluence environment. Atlassian’s vision for human-AI collaboration is that these agents become “virtual team members,” autonomously pursuing goals using the organization’s knowledge base (your pages, tickets, and more). In other words, you can augment your team with an AI that truly understands your projects and workflows.

Identifying Workflow Gaps (Where AI Can Help)

Every team has pain points or repetitive chores that sap time. Start by spotting these workflow challenges; they’re the best opportunities for a custom AI agent to help. Some examples of gaps an AI agent could fill include:

• Release management drudgery: Imagine an agent that automatically gathers release notes from Confluence and compiles a draft Jira ticket for your next release, sparing you the manual prep work each time.

• Onboarding new hires: A bot could answer common questions and guide new team members through initial tasks by pulling information from your company’s playbooks and documentation.

• Report generation: Instead of manually collating data every week, an AI agent could fetch stats from Jira and Confluence to generate status reports or project updates on a schedule.

• Compliance checks: For regulated industries, an agent might run through a checklist on each issue or page to ensure standards are met, flagging anything that needs review.

Overview of Tools: Rovo Studio vs. Forge

Building a custom AI agent in the Atlassian ecosystem can be done in two primary ways:

• Rovo Studio: This is Atlassian’s new no-code/low-code app for creating and managing AI agents and automations. Rovo Studio provides a user-friendly interface to configure an agent’s behavior without writing code (perfect for power users or admins). You can select data sources (like specific Confluence spaces or Jira projects), define how the agent should respond to certain prompts, and set up automations, all through a visual builder.

• Atlassian Forge: Forge is Atlassian’s cloud app development platform, ideal for developers who want full control. Using Forge, you can code a custom Rovo agent by defining a rovo:agent module in a Forge app. Forge takes care of the heavy lifting like hosting and security, so you can focus on the agent’s logic. This approach is more technical but offers maximum flexibility: for example, you could integrate with external APIs or implement complex decision-making in your agent’s code. (Atlassian even provides a “Hello World” Forge Rovo agent tutorial to help developers get started quickly.)

Define the Agent’s Purpose and Scope

The first step is deciding exactly what you want your AI agent to do. Will your agent primarily answer questions (by searching Confluence pages or Jira issues for information)? Will it perform actions (such as creating tasks, updating pages, or sending notifications) on behalf of users? Or perhaps it needs to do both? It’s important to narrow the focus to a specific workflow or problem. For example, you might create an agent devoted solely to onboarding new engineers, or one that manages the release notes process. By clearly defining the agent’s purpose and boundaries, you ensure it has a clear goal and remains effective (rather than trying to do a bit of everything and underperforming).

Design the Agent’s Skills (Prompts & Actions)

Once the goal is set, outline what skills and knowledge the agent needs:

• Craft clear prompt instructions: Think about how to explain the task to the AI. You might write a prompt template like, “When asked to generate a project status update, gather all incomplete Jira issues tagged for that project and summarize the progress across each.” Clear instructions help the agent understand exactly what is expected. Essentially, you’re programming the agent’s “brain” with guidelines.

• Define the actions it can take: Decide what the agent is allowed (and not allowed) to do. Can it create new Jira tickets? Post comments in Confluence? If so, specify those actions. You might configure an agent that, upon receiving a certain trigger or question, will execute tasks (for instance, closing all resolved issues in a version, or updating a page with fresh content). Each action should be purposeful and tied to the agent’s main goal.

• Set the context and data scope: An AI agent isn’t useful if it wanders off-topic. Link it to the relevant knowledge base (maybe a set of Confluence spaces, specific Jira projects, or particular types of content). This ensures the agent’s answers and actions stay on point. By limiting scope, you also prevent it from pulling in irrelevant info. For example, an HR onboarding agent might be connected only to HR policies and onboarding guides, so it won’t draw on engineering documentation.

[Suggested image: "Person training or configuring an AI chatbot, symbolizing an agent being given instructions and context"]

Development Process (No-Code & Code Options)

With a plan in place, it’s time to build your agent. Depending on your comfort with coding, there are two main approaches you can take.

For non-developers, the Rovo Studio app provides a visual way to set up an agent. In Rovo Studio, you’ll configure triggers (for example, a schedule or a specific command that summons the agent), define how the agent should respond to prompts, and connect the agent to relevant data. You might create sample question-and-answer pairs to train the agent’s responses, or specify which Confluence spaces and Jira projects it can draw information from. The beauty of this no-code path is speed: you can often configure a basic agent in just a few hours using menus and forms.

For those with programming skills, Atlassian Forge offers a coding route to build the agent. Using Forge, you would create a new Forge app and define a rovo:agent module in its manifest (this tells Atlassian that your app provides a custom AI agent). Then you implement the agent’s logic in code (usually JavaScript/TypeScript). This allows for advanced customization (perhaps integrating with an external API or adding complex decision rules). Atlassian provides helpful tutorials (like a Forge “Hello World” agent example) to get you started, and even this coded approach is quite approachable: you might go from idea to a working prototype in a day or two.

Testing and Iteration

Before unleashing your new AI teammate on mission-critical work, test it thoroughly:

• Sandbox the agent: Try it out in a safe environment first; for instance, use a test Jira project or a private Confluence space. This way, any mistakes are harmless.

• Pose real-world scenarios: Ask the agent various questions or give it tasks it’s meant to handle, and see what it does. Does it fetch the right information and perform the correct actions? If it’s summarizing content or generating text, check that the tone and details match your team’s standards.

• Check permissions and safety: Ensure the agent only accesses what it should. Atlassian’s Rovo agents respect the underlying permissions of Confluence and Jira, thanks to the Teamwork Graph connecting all your org’s data. Still, double-check that your custom agent isn’t inadvertently revealing anything sensitive or acting outside its bounds. For example, if it’s meant for one project, verify it’s not pulling data from another.

• Refine and improve: It’s rare to get everything perfect on the first try. Maybe the agent’s summary missed a key detail, or perhaps it gave a confusing response to a certain query. Use these findings to tweak its prompts or rules. You might need to add an extra instruction (“Never include financial data in responses,” for instance) or adjust its access to data. Iteration is part of the process: test, learn, and make the agent better.

Real-World Example: “Release Notes Assistant” Agent

To make this concrete, let’s walk through a mini case study. Imagine your team spends hours every release compiling the release notes: gathering issues, writing up summaries, and formatting a Confluence page. A custom AI agent could take over that job and act like a release assistant.

First, define the agent’s purpose. In our example, the goal is for the agent to gather all resolved Jira issues in a given release version and draft a summary of those changes. We make sure this scope is clear: the agent focuses only on that release’s issues and nothing else.

Next, design the agent’s skills. We would give the agent a prompt instruction such as, “Generate the release notes for version X by listing all the issues completed, with their summaries.” We also decide what actions it needs: in this case, the ability to read from the Jira project and to create a new Confluence page for the notes. By configuring these specifics (what to pull, and where to output it), we equip the agent with the necessary know-how to do the task.

Then, build and configure the agent. Using Rovo Studio, we connect the agent to our Jira project (so it can query issues by release tag) and to Confluence (so it can publish the results). We set up a template for the release notes page layout. All of this is done with no coding, just using the Studio interface to select the project, the query (e.g. issues in version X), and the output format. (If we wanted more advanced formatting or logic, a developer could do this via Forge, but in our case the no-code route suffices.)

After that, test the agent on a sample release. We try it out with a version that just closed. The agent dutifully creates a draft Confluence page with a bullet list of issues and their summaries. Success! However, we notice it included a few internal ticket titles that shouldn’t go to customers. That’s valuable feedback: we tweak the agent’s prompt or filters (for example, telling it to skip any issues marked “internal”) and run it again. Now the output looks clean.

Finally, deploy and reap the results. With the agent refined, the next time a release is ready, anyone on the team can trigger our “Release Notes Assistant.” Within seconds, they get a ready-made draft of the release notes. Instead of spending half a day manually assembling this document, the team only needs to do a quick review and polish. The AI agent has saved hours every release cycle, and it also reduces human error (no more accidentally omitting a Jira issue from the notes).

[Suggested image: "Software team celebrating as an AI agent automatically generates release notes on a screen"]

Governance and Maintenance

Creating a custom AI agent isn’t a “set it and forget it” affair. You’ll want to manage it over time:

• Assign an owner: Ensure someone on the team (for example, a project lead or system admin) is responsible for the agent. This person will monitor its performance and be the go-to for any issues.

• Periodic reviews: As your projects and content evolve, review the agent’s behavior periodically. Maybe the HR policies changed, or your Jira workflow was updated; you’ll need to update the agent’s prompts or scope to reflect those changes. Atlassian’s platform itself is evolving fast, so keep an eye out for new features or required changes (like updates to the Forge framework or Rovo capabilities).

• Permission controls: Treat your AI agent like a team member when it comes to permissions. If it’s an agent that interacts with Confluence or Jira, make sure it only has access to the spaces and projects it needs. Fortunately, Rovo agents obey the same permission schemes as users (they won’t see content they’re not permitted to), but it’s good practice to double-check. For example, if you have a confidential project, don’t grant the agent user account access to it unless necessary.

Conclusion

Custom AI agents can act like tireless team members, handling repetitive or complex cross-tool tasks 24/7 without complaint. By leveraging Atlassian’s open platform (Rovo AI plus Forge for extensibility), teams can tailor their collaboration environment as never before. If you have a tedious process or a knowledge gap, there’s potential for an AI agent to fill it. It’s an exciting time for human-AI collaboration in the workplace, and forward-thinking teams are already brainstorming their next “virtual teammate.” What workflow bottleneck would you eliminate with a custom AI agent?