Rovo Agent Pricing in Jira Automation: Cost per Agent Call

Rovo agent pricing in Jira automation comes down to one number: a Rovo agent inside a rule costs 10 Rovo credits each time the rule calls it. We built eight rules on our test site on 23 October 2026 and read the org's Rovo credits meter after each run. Twelve calls on the Quick answers tier all cost 10, and an agent switched to Claude Sonnet 4.6 cost 13.

You pay per question to the agent. Rule runs don't matter. One run of a rule that branched over three sub-tasks cost 30 credits, and a scheduled rule cost 20 because its JQL found two work items. Jira Standard gives each seat 25 credits a month. That's 2.5 agent calls per person.

From 3 December 2026 Atlassian bills usage above the pool at $0.01 a credit. Say a rule triages each new work item and your people raise ten a month each. If nothing else uses the pool, that's roughly 75 cents per seat a month on Standard, and $1.00 if Rovo Chat already spends it. At 200 seats that's $150 to $200 a month for one rule, which runs on each new work item whether anyone reads the comment or not.

Our earlier Rovo credits per user piece measured Chat and left agent runs out. This one measures them, and the per-seat numbers below sit next to our 2027 usage budget for 50, 200 and 500 seats.

[!NOTE]
Prerequisites — Jira Cloud on a paid plan with Rovo, and Rovo agents allowed in automation. To read the Rovo credits meter you need to be an organization admin in Atlassian Administration. To build rules and read the automation audit log you need Jira admin (or project admin for project rules). Everything below was run on our wolfaenpak test site on 23 October 2026 between 07:28 and 08:37 UTC, under our test admin account, in a fresh company-managed project, one rule at a time. Atlassian's prices and allowances were read on Atlassian's own pages the same day.

An agent call cost 10 credits, and a rule pays per call

We named the rules ROVO-A1 to ROVO-A8 and ran them against work items in a scratch project, RAGT. Here's what the meter showed:

1. 10 credits per agent call on the Quick answers tier. Twelve calls, nine runs, six rules. They used Atlassian's Bug Report Assistant or our own custom triage agent, on created, manual and scheduled triggers. For the branch rule and the scheduled rule, that's the run total divided by the number of agent calls.
2. Credits follow agent calls. One rule run can hold several. A branch over 3 sub-tasks cost 30. A scheduled rule whose JQL matched 2 work items cost 20.
3. A condition before the agent made the run free in credits. Our copy of Atlassian's "triage bugs" template skipped a Task at its issue-type condition, and the meter stayed at 321 for five minutes.
4. Think deeper alone still cost 10. Switching the model to Claude Sonnet 4.6 made it 13. That's one run on the default model (Gemini 3.5 Flash) and two on Sonnet, so treat it as a first reading.
5. No automation steps for the agent. Everything else in the rule was billed as steps. The agent call wasn't.
6. Only Allowance used kept up. It had moved by our first reading, about 22 seconds after the trigger, in almost every run, and within 45 seconds in all of them. The Features tab and the "Rovo credit usage in Automation" card were about half an hour behind.

How Atlassian bills a Rovo agent in a rule: Rovo credits and automation steps

Atlassian's automation doc is clear on the split: "Agentic components like Use Rovo, Use agent, or Use Jira Coding agent are billed separately under Rovo credits and do not consume automation steps." The Rovo licensing FAQ says the same from the other side, and adds that "a single automation rule can consume from both meters in one run, but each meter is tracked and billed independently". So the agent comes out of your Rovo credits, and the rest of the rule out of your automation steps.

Atlassian doesn't publish a per-call price for the agent step. The Rovo rate table has "Basic Rovo Agents (no model selection)" at "10 Rovo credits per billable event" and "Advanced Rovo Agents (with model selection)" at "Variable credits per billable event". Neither row names Use agent or automation. In our runs the basic case was 10, and switching the agent to Claude Sonnet 4.6 took it to 13, twice. We didn't price Use Rovo, the other agentic component, because we only built Use agent rules.

Atlassian's pages said this on 23 October:

Both pools are shared across the whole org, and Confluence seats add their own 25, 70 or 150 credits each. Atlassian's usage doc says "On December 3, 2026, extra usage billing takes effect", and its pricing FAQ says extra usage is on by default "for most organizations". Our test org shows "Extra usage disabled", so its new credit-consuming requests would pause at the pool instead of billing on. If you'd rather set a cap first, our Rovo usage limit tutorial walks through it.

Add a Rovo agent to a Jira automation rule (Use agent)

If you haven't built one yet, Atlassian's own template is the quickest way in. In your project go to Space settings > Automation > Templates, open Rovo AI Agents and pick Use Rovo Agent to triage bugs in Jira. That gives you a Work item created trigger, an issue-type condition, a Use agent step and an Add comment to work item step that posts {{agentResponse}}.

One catch: on our site the template opened with Let this agent take actions already switched on, even though Atlassian's doc says the toggle is "off by default (including exisiting automations)". Switch it off before you save unless you want the agent writing to your work items.

In the Use agent panel you pick the agent from a list of Atlassian's agents and your own. We looked for a model or reasoning setting there and found none. Those live on the agent itself, in Rovo Studio, so if someone changes an agent's model, each rule that uses it changes price too.

The prompt takes smart values like {{issue.key}} and {{issue.summary}}, and the agent's text comes back as {{agentResponse}} for the next step. With actions switched on, the agent can change your work items. With a User's account it does that with the permissions of whoever set up the rule (our panel said "This agent will use Mihai Perdum's permissions"). With an Agent's account it uses only what the agent itself has been granted. Our piece on Rovo agent permissions covers who ends up acting.

You should see the run show Success in the audit log, and a comment from "Automation for Jira" on the work item. Ours arrived 15 to 31 seconds after the trigger. If the audit log says "Agent invocation failed" but the comment did arrive, count the call: ROVO-1071 is an open bug where the log reports that "even though the agent completed successfully".

We first tried to create the template rule through the automation REST API and got a 400 back, because a Use agent step needs its own Rovo connection. The builder worked first time. If you script rules, give each new rule its own new connection.

Measure what one run of your rule costs

The rule won't tell you what it spent. You measure it from outside, about ten minutes per rule.

[[steps]]

1. Open the meter — in Atlassian Administration go to Insights > Platform usage > Rovo credits, Usage tab, current billing period, and write down Allowance used. Leave Credits this period and the Features tab alone for this; they lag.
2. Check nothing else is spending — reload after two minutes. If Allowance used moved, someone else is using Rovo and your reading will be off, so try again later.
3. Switch on only the rule you're testing — then trigger it once: create a work item, run the manual trigger, or wait for the schedule.
4. Read Allowance used again after two minutes — the difference is what one run cost.
5. Open the audit log — in Automation > Audit log, expand the run and count how many times the Use agent component ran. Credits divided by agent calls is your price per call.
6. Switch the rule off — if it was only a test. Our 13 test runs cost 156 credits, which would be $1.56 over the pool, and they came out of the same pool everyone else uses.

Allowance used should show no change during the quiet check and then move once, by the price of the run. Here's our first run (ROVO-A1, one new work item), polled every 20 seconds:

quiet check   [0 s, 291] [21 s, 291] [43 s, 291] [64 s, 291] [85 s, 291] [106 s, 291] [128 s, 291]
after trigger [22 s, 301] [44 s, 301] [65 s, 301] [86 s, 301] [107 s, 301] [129 s, 301] [151 s, 301]

And the same run in the audit log, Success in 3.67 seconds:

jira.issue.event.trigger:created x1
rovo.invoke-agent.action x1
jira.issue.comment x1

Here's the whole run log. RAGT is the scratch project and the keys are the work items each run touched:

run        rule                                   items          meter       credits
A1-r1      created -> agent -> comment            RAGT-8         291 -> 301  10
A1-r2      created -> agent -> comment            RAGT-9         301 -> 311  10
A2-r1      template, Bug passes condition         RAGT-10        311 -> 321  10
A2-r2      template, Task stopped by condition    RAGT-11        321 -> 321   0
A5-r1      manual -> agent -> comment             RAGT-7         321 -> 331  10
A5-r2      manual -> agent -> comment             RAGT-7         331 -> 341  10
A3-r1      manual -> branch 3 sub-tasks -> agent  RAGT-2,3,4     341 -> 371  30
A6-r1      created -> custom triage agent         RAGT-12        371 -> 381  10
A6-r2      created -> custom triage agent         RAGT-13        381 -> 391  10
A4-r1      scheduled JQL, 2 matches               RAGT-5,6       391 -> 411  20
A8-r1      Think deeper, Claude Sonnet 4.6        RAGT-14        411 -> 424  13
A7-r1      Think deeper, default model            RAGT-15        424 -> 434  10
A8-r2      Think deeper, Claude Sonnet 4.6        RAGT-16        434 -> 447  13

I added the 13 runs up to check: 156, the same as the meter's 291 to 447. Our quiet checks before the runs were all flat. Nothing else on the org was spending.

Count the automation steps from the Usage tab, not the audit log

The audit log counts the agent as a component, and the bill doesn't. The Usage tab is what Atlassian bills, and it leaves the agent out.

On our branch rule the audit log showed 8 components: the trigger, the branch, 3 agent calls and 3 comments. The Usage tab billed 5 steps. On the six rules whose numbers had caught up, billed steps were exactly the audit count minus the agent calls. If you budget steps from the audit log, as we suggested in our automation steps tutorial, take one off for each agent call.

Next to credits, steps are a rounding error. Trigger plus comment is 2 steps a run, and at $0.50 per 1,000 steps that's a tenth of a cent. The agent call in the same run is 10 cents once you're over the pool.

Jira Rovo agent cost per seat at 50, 200 and 500 seats

A typical first rule has an agent triage each new work item and post a comment. Its monthly cost is one formula:

rule's overage = min(rule credits, max(0, what the org already uses + rule credits - pool))
cost a month   = rule's overage x $0.01
rule credits  = new work items a month x agent calls per item x 10

My assumptions: 10 credits per call (what we measured on Quick answers), one call per work item, and the Jira-only pool of 25 credits a seat on Standard or 70 on Premium. The Jira + Confluence column assumes each Jira seat also has a Confluence Standard seat, so 50 credits a seat. For new work items per seat, count last month's new work items and divide by your Jira seats. In Jira search the JQL is created >= startOfMonth(-1) AND created < startOfMonth(), with project in (...) added if your rule only covers some projects. If you'd rather script it, Jira's approximate-count endpoint takes the same JQL (use an API token):

curl -s -u "$EMAIL:$API_TOKEN" -X POST \
  -H 'Content-Type: application/json' \
  https://your-site.atlassian.net/rest/api/3/search/approximate-count \
  -d '{"jql":"created >= startOfMonth(-1) AND created < startOfMonth()"}'

You should see one number. It only counts work items your account can browse, and a wrong or missing token prints {"count":0} without an error, so check the token if you get 0. Ours, run on 23 October for September:

{"count":14398}

That's high because our test tools create work items by the thousand. A real team of 200 raising ten each would show about 2,000.

Cost per seat a month, by new work items per seat:

Company size doesn't change the per-seat figure. It only multiplies it. At 10 new items per seat on Standard, with the pool otherwise unused, that's $37.50 a month at 50 seats, $150 at 200 and $375 at 500. With the pool already spent it's $50, $200 and $500. Steps barely register: 20 a seat a month against 400 on Standard.

Which column is yours? I'd set the Rovo credits Users tab on Last 30 days, add up what your org used, and compare it with Allowance on the Usage tab. The gap is your buffer. It absorbs a new rule before billing starts. If last month's use already sits near the allowance, budget from the last column.

Two kinds of rule cost more than a seat count suggests, because they grow with work items:

1. A branch over related items. Our 3 sub-tasks cost 30. A parent with 25 sub-tasks would cost 250 credits, $2.50 a run over the pool, at the same per-call price. We only tested 3.
2. A scheduled sweep. A rule that asks an agent about 20 open items once each weekday is 440 calls a month over 22 weekdays: 4,400 credits, or $44 once you're over the pool. Make it hourly over an eight-hour day and it's 35,200 credits, $352. With a Sonnet 4.6 agent at 13 credits the daily version is $57.20.

Choose the model and the reasoning tier on the agent, not the rule

We duplicated Bug Report Assistant twice in Rovo Studio. One copy got Think deeper on the Default model, which the picker showed as Gemini 3.5 Flash. The other got Think deeper with Claude Sonnet 4.6. Same prompt, same kind of work item.

The Default-model copy cost 10 and the Sonnet copy cost 13, in both of its runs. So on our short triage task (about 120 words of answer) the premium model added 30%. I'd honestly half expected a multiple. Atlassian's rate card puts these agents under "Variable credits per billable event", and for Think deeper it names reasoning steps, search volume, tools invoked and model power as what moves the price. We didn't try Opus-class models or long multi-tool tasks. That's where I think the bigger numbers will be.

Atlassian's reasoning-tier doc carries a warning worth taking literally for automation: "If you're setting up autonomous or high-volume agents, carefully consider which reasoning tier is most appropriate for your task. These tasks can quickly consume credits." Because the setting lives on the agent, whoever edits a shared agent in Rovo Studio reprices the rules that call it, and nothing in the rule's builder shows that.

Put the condition before the agent

Our copy of Atlassian's template checks the issue type before it calls the agent, and a Task stopped there for 2 steps and 0 credits. If your rule calls the agent first and decides afterwards whether to use the answer, you pay 10 credits for each work item it looks at.

Scheduled rules work the same way. Our sweep matched 2 work items and paid for 2 calls. Twice the matches, twice the bill.

What we didn't measure

No agent call failed or timed out for us. So we can't tell you whether one is billed. None of the Atlassian pages or tracker tickets we read say either. Our agents never used write tools in a run, so an agent that edits work items may cost more than one that only answers. Each rule ran once or twice. Repeats never differed, but it's a small sample.

We also didn't run a rule into an empty pool. Atlassian's Rovo plans FAQ says that with extra usage off, "new credit-consuming AI features and enriched Teamwork Graph API and tool calls are paused until the allowance resets next month", and that an "Agent task" already in progress "will complete". What a Use agent step does at that moment (skip, fail or post an empty comment) is something we haven't seen.

The Usage tab has a Rovo credits column per flow, which helps you find the expensive rule. On our site it read 90 when the meter had moved 156, so check it again the next day before you act on it.

If your screens don't match

If there's no Rovo AI Agents category in Templates, or Use agent is missing from the action list, an admin may have turned off agents in automation, or your plan may not include Rovo. If the meter doesn't move after a run, check the audit log first: a run that stopped before the agent costs nothing. And if Allowance used jumps by more than your rule should cost, someone else is using Rovo at the same time, so repeat the quiet check.

What you have now

[[takeaways]]

• A per-call price from our test site: 10 Rovo credits on Quick answers, 13 with Claude Sonnet 4.6, and no automation step for the agent.
• A ten-minute way to measure your own rule from Allowance used and the audit log.
• A formula and a per-seat table for a triage rule: $0.30 to $0.75 a seat a month at 10 new items per seat when the pool has room, $1.00 when it's spent.
• What it doesn't cover: failed agent calls, agents that write, Opus-class models, or a rule running into an empty pool.

My recommendation before 3 December: list the rules with a Use agent step and move each condition in front of the agent. Then find the busiest one in the audit log, multiply its runs last month by its agent calls per run and by 10, and put that next to your Monthly average and Allowance. If the total goes over, set a monthly cap on Rovo credits so a busy sweep stops at a number you chose.

Have you got a rule that calls an agent on each new work item? I'd love to hear what it costs on your site, especially if it runs a Think deeper agent on a bigger model than ours.

Originally published on leanzero.net. More Atlassian, Forge and local-AI write-ups at leanzero.net/blog, and if you're planning a migration or a Forge app, that's what we do: leanzero.net/services.