Full disclosure up front: I work on the team that builds Mermaid Plus Diagrams for Confluence at NGPILOT. This post is the thinking behind our Rovo agent — why text-based diagrams are the format the AI era needs, and what an agent that actually operates your diagrams looks like. It is not a pitch; there is nothing here to buy.
The diagram is the last thing AI can't touch
Look at what AI teammates already do to a Confluence page: summarize it, translate it, rewrite the awkward paragraphs, draft the missing sections. Text is the one interface AI handles natively, and Confluence pages are text — so every page got more useful the day Rovo arrived.
Except the most information-dense thing on many pages: the diagram.
Ask an AI teammate to update the architecture diagram and you're back to square one. It's a PNG. The AI can't read it, can't edit it, can't put it back. Whatever process produced it — a drawing tool, an export, a screenshot — has to run again, by hand. In 2026 that's not a tooling gap. It's a format gap.
Text is the interface
We made the case for text-based diagramming in an earlier post — Why Mermaid wins the text-to-diagram standard in the AI era — so this one takes that as given and looks at what changes when an agent can operate the diagram. Mermaid is the best-known example: flowcharts, sequence, class, state, ER, mindmap, gantt, and a couple of dozen more diagram types, all expressed as plain text. A diagram whose source lives on the page as text checks every box at once:
Habit | Source in Confluence | Versioned like a page | Rendered on the page | AI can read & maintain it |
|---|
Screenshot from a drawing tool | ✕ (source lives elsewhere) | ✕ | ✕ (frozen image) | ✕ |
Mermaid in a code block | ✓ | ✓ | ✕ (copy the render back yourself) | ✓ |
Text source, rendered in place | ✓ | ✓ | ✓ | ✓ |
The third row is where both worlds meet: humans keep a diagram they can edit by hand, and AI gets a format it can read and write natively. And because the rendered diagram is page content — not an attachment — everyone who opens the page sees the current version, in every space, every export, with the page's own history.
Because it's text, the diagram becomes interoperable
Plain text is a two-way interface. The same paragraph of Mermaid can travel in every direction:
- sentence → diagram. Describe what you want; the Mermaid code is written and rendered.
- diagram → text. Ask for the diagram source and it lands in your chat, readable and reusable.
- text block → diagram. Mermaid you already pasted as a code block can be converted in place.
- change request → updated diagram. "Make the login flow a sequence diagram" — the source is rewritten and the render follows.
No export step anywhere. The text is the diagram; the render is just its current form on the page.
A Rovo agent, not a chatbot
Plenty of AI tools will happily generate a Mermaid snippet in a chat window. Then you copy it, paste it, re-render, re-upload — exactly the loop we're trying to kill.
That's why we built this as a Rovo agent wired directly into the app. The agent doesn't hand you an image; it operates on your real Confluence content, as you, with your permissions. Point it at any page or blogpost and it can:
- create a diagram from a natural-language sentence — any Mermaid v12 type, on a page or a blogpost,
- read the current diagram source and version and share it in chat,
- update the diagram in place, keeping the macro's existing theme and alignment settings,
- convert Mermaid code blocks already on the content into rendered macros — with smart detection, so only blocks that actually look like Mermaid are touched (a
python block stays a python block).
Every write lands as a normal content version with a single confirmation card — so the change is versioned, attributed, visible to collaborators the moment it's saved, and reviewable in the page history like any other edit.
Humans keep the pen
An agent that edits pages is only trustworthy if the human paths stay intact:
- Manual editing is untouched. The macro editor is right there on the page; click in and revise the code by hand anytime. The agent is a shortcut, not a gatekeeper.
- One confirmation card per write. Nothing happens without your approval, and if you ever see two cards for one request, the first attempt failed internally and retried — please report that case.
- No silent overwrites. If the page changed between reading and writing, the write is refused with the current version and the agent re-reads and retries.
Prompts we use every day
Plain language, no templates required — these work inline on a page, on a blogpost, or in a space context:
Direction | Prompt |
|---|
sentence → diagram | Create a page called "Deployment flow" in this space with a flowchart: Sign in -> Build -> Test -> Deploy
|
sentence → diagram (blogpost) | Create a blogpost called "Diagram of the day" in this space with a pie chart: 60 A, 40 B
|
diagram → text | Show me the diagram source on this page
|
change request | Change the diagram on this page to a mindmap with root "Roadmap" and children "Q1", "Q2"
|
change request (vague) | Make this better — on a page that already has a diagram
|
text block → diagram | Turn the Mermaid code blocks on this page into rendered diagrams
|
Every diagram type Mermaid v12 renders — and the 12 is the point
We track Mermaid releases closely: Mermaid Plus was the first Mermaid app on the Atlassian Marketplace to support Mermaid v12, the current major release, and it renders every diagram type v12 ships — flowchart, sequence, class, state, ER, mindmap, timeline, gantt, pie, journey, quadrant, sankey, xychart, gitGraph, C4 and the rest — plus ZenUML for UML sequence-style diagrams. The agent inherits all of it: create, update, and convert work across the whole type system, and you don't need to name the type — say what you want to show and the agent fits the diagram to it.
Behaviors worth knowing before you trust an agent with a page
A few things we learned while testing that make the agent predictable:
- It's anchored to the page where the conversation started. Navigate somewhere else and keep asking in the same chat, and it still works on the original page. Start a fresh conversation on the page you want to change — and if the agent ever sees a mismatch between the page you're mentioning and the conversation anchor, it asks you before writing anything.
- It won't invent content. If a page has no diagram to update, it says so and stops — it will not silently add one or spawn a workaround page. Say "add a diagram …" when you want one.
- Drafts and blogposts work. A Mermaid code block you just pasted without publishing is visible to the agent; it can update your draft directly (one caveat: refresh your open editor tab afterwards, or publishing from the stale tab can undo the agent's change). Blogposts are supported exactly like pages — say "blogpost" when you want one.
- Privacy. The agent runs on Atlassian infrastructure. Diagram code stays in your Confluence content and is not sent to external services.
Try it on your own pages
If you already have Mermaid code blocks in Confluence, that's the fastest start: ask the agent to convert one and watch the render appear in place. If you're starting fresh, describe a diagram in one sentence and see whether the text-first loop changes how your team keeps diagrams current.
Mermaid Plus Diagrams for Confluence
How much of your diagram work would you hand to an agent today — and which diagram would you never delegate?
I co-build this app at NGPILOT. Happy to answer questions in the comments — including criticism; we're actively improving the agent's behavior.
