Why can't a Rovo agent fill out a JSM request form?

It usually can — until the form crosses two specific thresholds Atlassian documents in its own troubleshooting guide. If a choice field on the form has more than 10 options, the agent cannot complete that field at all. If the form has more than 10 required fields total, the agent falls back to basic issue creation instead of populating the form, silently dropping the structured data you built the form to collect. Assets objects, Jira-linked fields, and embedded attachment fields aren't handled properly either, regardless of field count.

Is there a limit on how long a Rovo agent's instructions can be?

Not a hard character cap that Atlassian publishes, but a real practical one. Atlassian's own guidance says to keep instructions short, because an agent given a long list of instructions doesn't reliably execute all of them — it selectively prioritizes which parts to act on. That's a different failure mode from the 5-tool ceiling: a short instruction set with too many tools fails on tool selection; a long instruction set with few tools fails on which instructions it actually follows.

Can out-of-the-box Rovo agents like Figma or Replit access private data?

Not fully, and not reliably. Per Atlassian's own documentation on third-party MCP agents, private app content from Replit, Lovable, and Gamma can't be accessed through the OAuth smart-link flow those agents use — you have to open the external app directly. Content from all three may also fail to render inline via smart links. The Replit agent additionally runs on Beta MCP servers, which Atlassian flags as prone to instability, with limited support capability for bugs specific to that beta status.

How long does Rovo Deep Research take, and does that cause problems?

Up to 15 minutes per request, per Atlassian's own docs — it's the slowest mode Rovo offers, by design, because it's doing cross-project synthesis rather than a quick answer. That response time matters most if you're calling Deep Research from inside a Jira or Confluence Automation rule: automation rules have their own execution-time ceiling, and a Deep Research call that runs close to its full 15 minutes is working right at the edge of what an automation step can wait for.

What are the other hard ceilings on a Rovo agent I should know before building one?

The ones covered in depth elsewhere on this site: a recommended maximum of 5 tools per subagent before tool-selection accuracy drops, bulk Jira actions capped at 20 work items per run, agent-created calendar invites capped at 4 attendees, and a shared org credit pool (25/70/150 per user per month depending on plan) that works out to roughly 2-3 agent runs per Standard-tier user before dipping into the pool. None of the built-in tools reach outside Jira, Confluence, JSM, and Google — anything else needs a Forge build.

Rovo Agent Limits: What It Actually Can't Do

Ask a Rovo agent to fill out a Jira Service Management form with an 11-option dropdown, and it will not complete that field — not slower, not degraded, just unable. That’s not a hypothetical: it’s in Atlassian’s own troubleshooting documentation, and it’s the kind of limit that only shows up once you’re mid-build with a real form, not while reading the feature page. This page collects the specific, currently-documented failure modes and hard ceilings for Rovo agents — the ones a vendor page won’t lead with — verified against Atlassian’s live docs in August 2026. It’s not a build-vs-buy decision or a step-by-step (we cover those separately); it’s the honest list of where the walls actually are.

The JSM form cliff nobody warns you about

If you’re building an agent to raise or fill Jira Service Management requests, this is the limit that will bite first, and Atlassian has an entire troubleshooting page dedicated to it — How to make Rovo Agents work well with JSM forms:

A choice field with more than 10 options breaks outright. The agent cannot complete that field. Not “sometimes gets it wrong” — cannot complete it.
More than 10 required fields on a form, and the agent gives up on the form entirely, falling back to basic issue creation instead — meaning your carefully structured request type silently gets a plain ticket with none of the form data populated, unless you’re specifically watching for it.
Three field types don’t work regardless of count: Assets objects, Jira-linked fields, and attachment fields embedded in the form. These aren’t edge cases you can design around by trimming option counts — they’re categorically unsupported.

Atlassian’s own workaround guidance is worth repeating exactly because it’s an admission the limit is real: simplify the form to stay under both the 10-option and 10-required-field thresholds, use Automation to map fields as a substitute for the unsupported Jira-linked fields, and — a detail easy to miss — make sure the JSM project is configured under “Knowledge bases (Jira Service Management)” rather than plain “Jira” in the agent’s knowledge scope, or the “Raise a request” skill won’t engage correctly at all.

If you’re evaluating an agent for a complex intake form (IT requests, HR onboarding, anything with more than a handful of structured fields), count your form’s fields and options before you build, not after.

Instructions degrade with length — a different failure mode than the tool-count ceiling

Rovo Agent Studio vs. Forge already covers the documented 5-tool ceiling in depth. There’s a second, separate ceiling worth knowing: instruction length. Per Atlassian’s own guidance on writing agent instructions, you should “keep your instructions relatively short to start with,” because an agent given a long, dense instruction set doesn’t reliably execute the whole thing — it selectively prioritizes which parts to act on, rather than following the full list every time.

That’s a distinct failure from the tool-count problem. A tightly-scoped 2-tool agent can still misbehave if its instructions try to cram in ten different conditional cases and edge-case handling in prose — because the underlying mechanism (an LLM re-interpreting a prompt every turn, not executing fixed code) is the same one that makes the tool-count ceiling real. Both point at the same underlying truth: Studio agents are reliable at one clearly-scoped job, not many jobs bundled into one.

Out-of-the-box connected agents have their own gaps

Not every limitation is about agents you build — Atlassian ships a set of out-of-the-box third-party MCP agents (Figma, Canva, Box, Amplitude, HubSpot, Intercom, Gamma, Replit, Lovable) that connect to those tools directly. Per Atlassian’s own documentation, current as of the page’s last update:

Private app content from Replit, Lovable, and Gamma can’t be accessed through their OAuth smart-link flow — you have to leave Rovo and open the external app directly to see it.
Content from those same three may not render inline via Atlassian smart links at all.
The Replit agent runs on Beta MCP servers, which Atlassian itself flags as prone to instability, with the explicit caveat that its support team has limited ability to resolve bugs specific to that beta status.

Worth knowing if you’re evaluating whether a prebuilt connected agent replaces a custom build for a design or dev tool — right now, for these three, it doesn’t fully.

Deep Research’s 15-minute ceiling meets automation’s own clock

Rovo pricing and credits, explained already covers what Deep Research costs (100 credits per request, the most expensive single action in Rovo). The ceiling that page doesn’t cover is time: per Atlassian’s own Deep Research docs, a Deep Research request can take up to 15 minutes to return a response — by far the slowest mode Rovo offers, because it’s synthesizing across projects rather than answering directly.

That matters specifically if you’re calling an agent’s Deep Research skill from inside a Jira or Confluence Automation rule rather than chatting with it directly. Automation rules run against their own execution-time limits, and a Deep Research call that takes close to its full 15 minutes is running right up against what an automation step is built to wait for. If you’re wiring Deep Research into an automated flow rather than an interactive chat, that’s worth testing under real conditions before you rely on it — a call that works fine when you’re watching the chat window isn’t guaranteed to behave the same way fired from a rule.

The ceilings already covered elsewhere, briefly

These are documented, real, and worth knowing, but they get full treatment on other pages rather than repeated here:

5 tools per subagent (recommended max) — past this, agents start picking the wrong tool or dropping steps. Full decision framework: Rovo Agent Studio vs. Forge.
Bulk Jira actions cap at 20 work items per run; agent-created calendar invites cap at 4 attendees. Covered in How to build a Rovo agent.
No tool outside Jira, Confluence, JSM, and Google, and no custom conditional logic — Studio’s entire tool surface is those four categories, full stop. Also in Rovo Agent Studio vs. Forge.
A shared, metered credit pool — 25/70/150 credits per user per month depending on plan (Standard/Premium/Enterprise), pooled org-wide, working out to roughly 2-3 agent runs a month per Standard-tier user before leaning on the shared pool. Full breakdown: Rovo pricing and credits, explained.

What this adds up to

None of these limits are secret — they’re all in Atlassian’s own documentation. But they’re scattered across a troubleshooting KB article, a writing-instructions guide, a third-party-agents page, and a Deep Research doc, which is exactly why nobody reads them before they build. The pattern across all of them is the same one: Rovo agents (Studio ones especially) are genuinely reliable at one clearly-scoped job with a small, well-defined surface — a handful of tools, a form under 10 fields and 10 options per choice field, a short instruction set. Push past any one of those boundaries and the failure isn’t a crash, it’s silent degradation: a field that doesn’t get filled, an instruction that doesn’t get followed, a request that quietly becomes a plain ticket instead of the structured one you designed.

If what you’re building bumps into one of these on a form or a workflow that actually matters, that’s usually a Forge job, not an Agent Studio one — we build those too →