# Mermaid 12.3 in Confluence: five new diagram types November 4, 2026 · 13 min read [NGPilot](https://ngpilot.com) Mermaid 12.3 is now live in [Mermaid Plus Diagrams & AI Agent for Confluence](https://marketplace.atlassian.com/apps/1236814/mermaid-plus-diagrams-ai-agent-for-confluence/), and with it come five new diagram templates in the app: **Wardley strategy maps**, **event modeling flows**, **BPMN process shapes**, **animated step-by-step flows**, and **agent workflow diagrams**. Each one closes a specific documentation gap that used to force teams into a separate drawing tool — or into whiteboard photos nobody could update. **Quick answer:** Mermaid 12.3 adds BPMN element shapes for flowchart nodes, step animation on flowchart edges, and new edge markers — and Mermaid Plus pairs the engine bump with five new templates: Wardley maps (`wardley-beta`) for build-vs-buy planning, event modeling (`eventmodeling`) for event-driven design sessions, BPMN process notation for process audits, animated flows for onboarding and runbooks, and agent flows (`agentflow-beta`, which landed in Mermaid 12.0 and was still missing from most editors) for documenting AI workflows. Type `/mermaid+` on a page, pick a template from the middle panel, and the diagram renders as you edit. Existing diagrams keep working and upgrade themselves on next view. ## Which diagram solves which problem[​](#which-diagram-solves-which-problem "Direct link to Which diagram solves which problem") | You are... | Use | The problem it solves | | --------------------------------------------------- | ------------------ | --------------------------------------------------------------------------------------------------------------------------- | | Planning a roadmap or arguing build-vs-buy | **Wardley map** | Strategy debates re-litigated every quarter because nobody shares a picture of what is commodity vs novel | | Designing an event-driven feature with stakeholders | **Event modeling** | Whiteboard photos die in Confluence; the UI → command → event flow isn't reviewable by anyone who missed the session | | Documenting a business process for auditors or ops | **BPMN shapes** | Free-form flowcharts don't read as official process; drawing-tool BPMN goes stale the week after the workshop | | Onboarding new hires or writing incident runbooks | **Animated flow** | A 10-arrow diagram makes readers guess where to start and which path is "the" happy path | | Shipping an AI agent that others must review | **Agent flow** | Agent workflows live in stale slides; security and compliance need to see exactly what the agent reads, calls and hands off | ## What's new in Mermaid 12.3 (and what the app picks up)[​](#whats-new-in-mermaid-123-and-what-the-app-picks-up "Direct link to What's new in Mermaid 12.3 (and what the app picks up)") | Change | What it means for your pages | | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | | **Wardley maps** (`wardley-beta`) | Strategy maps as text: components on a visibility × evolution grid, `evolve` arrows, build/buy/outsource decorators | | **Event modeling** (`eventmodeling`) | Event-driven system flows on an inferred UI / Command / Events timeline, written with numbered time frames | | **BPMN element shapes** | Flowchart nodes can now render as real BPMN notation — events, gateways, activities, data objects, data stores, annotations | | **Step-by-step flow animation** (`e1@{ step: 1 }`) | Edges play in order with a traveling dot — handy for request walkthroughs (disabled automatically for reduced-motion readers) | | **Agent workflows** (`agentflow-beta`) | Document AI agents as text: a `flow` block per agent with typed steps, `connector` blocks for the external systems it calls | | **New edge markers** | Open-arrow and hollow-circle heads, so a notation can tell two kinds of flow apart | | **Backward compatible** | Existing diagram code renders unchanged; layout and styling may shift subtly | ## Wardley maps: strategy as text[​](#wardley-maps-strategy-as-text "Direct link to Wardley maps: strategy as text") A Wardley map answers a question that requirement docs keep losing: *which parts of our value chain are commodities now, and which are still novel?* Writing it in Mermaid means the map lives next to the PRD instead of in a screenshot. Paste this into a Mermaid+ macro (or start from the **Wardley** template in the panel): ``` wardley-beta %% coordinates are [visibility, evolution] title Tea Shop Value Chain %% anchor: a user or business need (bold label) anchor Business [0.95, 0.63] %% component: a capability on the map; (build)/(buy) are strategy decorators component Cup of Tea [0.79, 0.61] component Tea [0.63, 0.81] (build) component Hot Water [0.52, 0.80] component Kettle [0.43, 0.35] (buy) component Power [0.10, 0.70] %% dependencies point from consumer to dependency (A -> B: B depends on A) Business -> Cup of Tea Cup of Tea -> Tea Cup of Tea -> Hot Water Hot Water -> Kettle Kettle -> Power %% evolution arrows: where a component is heading evolve Kettle 0.62 evolve Power 0.89 note "Standardising power allows Kettles to evolve faster" [0.30, 0.49] ``` ![A Wardley map of a tea shop value chain rendered in Confluence](data:image/svg+xml;base64,<svg id="w-dew9ffskc1s" width="100%" xmlns="http://www.w3.org/2000/svg" style="background-color: white; max-width: 100%; height: auto; max-width: 900px;" viewBox="0 0 900 600" role="graphics-document document" aria-roledescription="wardley"><g class="wardley-map"><rect class="wardley-background" width="900" height="600" fill="white"></rect><text class="wardley-title" x="450" y="24" fill="#131300" font-size="12.600000000000001" font-weight="bold" text-anchor="middle" dominant-baseline="middle">Tea Shop Value Chain</text><g class="wardley-axes"><line x1="48" x2="852" y1="552" y2="552" stroke="#333333" stroke-width="1"></line><line x1="48" x2="48" y1="48" y2="552" stroke="#333333" stroke-width="1"></line><text class="wardley-axis-label wardley-axis-label-x" x="450" y="588" fill="#131300" font-size="12" font-weight="bold" text-anchor="middle">Evolution</text><text class="wardley-axis-label wardley-axis-label-y" x="16" y="300" fill="#131300" font-size="12" font-weight="bold" text-anchor="middle" transform="rotate(-90 16 300)">Visibility</text></g><g class="wardley-stages"><text class="wardley-stage-label" x="148.5" y="568" fill="#131300" font-size="10" text-anchor="middle">Genesis</text><line x1="249" x2="249" y1="48" y2="552" stroke="#000" stroke-width="1" stroke-dasharray="5 5" opacity="0.8"></line><text class="wardley-stage-label" x="349.5" y="568" fill="#131300" font-size="10" text-anchor="middle">Custom Built</text><line x1="450" x2="450" y1="48" y2="552" stroke="#000" stroke-width="1" stroke-dasharray="5 5" opacity="0.8"></line><text class="wardley-stage-label" x="550.5" y="568" fill="#131300" font-size="10" text-anchor="middle">Product</text><line x1="651" x2="651" y1="48" y2="552" stroke="#000" stroke-width="1" stroke-dasharray="5 5" opacity="0.8"></line><text class="wardley-stage-label" x="751.5" y="568" fill="#131300" font-size="10" text-anchor="middle">Commodity</text></g><g class="wardley-links"><line class="wardley-link" x1="553.3466711455914" y1="79.08415664300439" x2="539.6133288544087" y2="147.95584335699562" stroke="#333333" stroke-width="1"></line><line class="wardley-link" x1="543.8033573206228" y1="156.52968367123765" x2="693.8766426793773" y2="231.79031632876234" stroke="#333333" stroke-width="1"></line><line class="wardley-link" x1="542.920181527573" y1="157.83098652966828" x2="686.719818472427" y2="285.9290134703317" stroke="#333333" stroke-width="1"></line><line class="wardley-link" x1="685.2466065464694" y1="290.66639559715907" x2="335.3533934535306" y2="334.5336044028409" stroke="#333333" stroke-width="1"></line><line class="wardley-link" x1="334.565252186624" y1="338.3328953222434" x2="605.634747813376" y2="498.5471046777566" stroke="#333333" stroke-width="1"></line></g><g class="wardley-trends"><line class="wardley-trend" x1="329.4" y1="335.28" x2="538.48" y2="335.28" stroke="#dc3545" stroke-width="1" stroke-dasharray="4 4" marker-end="url(#arrow-w-dew9ffskc1s)"></line><line class="wardley-trend" x1="610.8" y1="501.6" x2="755.5600000000001" y2="501.6" stroke="#dc3545" stroke-width="1" stroke-dasharray="4 4" marker-end="url(#arrow-w-dew9ffskc1s)"></line></g><g class="wardley-nodes"><g class="wardley-node wardley-node--anchor"><text x="554.52" y="70.20000000000005" class="wardley-node-label" fill="#000" font-size="10" font-weight="bold" text-anchor="middle" dominant-baseline="middle">Business</text></g><g class="wardley-node wardley-node--component"><circle cx="538.44" cy="153.83999999999997" r="6" fill="white" stroke="#333333" stroke-width="1"></circle><text x="546.44" y="145.83999999999997" class="wardley-node-label" fill="#131300" font-size="10" font-weight="normal" text-anchor="start" dominant-baseline="auto">Cup of Tea</text></g><g class="wardley-node wardley-node--component"><circle class="wardley-build-overlay" cx="699.24" cy="234.48000000000002" r="12" fill="#eee" stroke="#000" stroke-width="1"></circle><circle cx="699.24" cy="234.48000000000002" r="6" fill="white" stroke="#333333" stroke-width="1"></circle><text x="717.24" y="216.48000000000002" class="wardley-node-label" fill="#131300" font-size="10" font-weight="normal" text-anchor="start" dominant-baseline="auto">Tea</text></g><g class="wardley-node wardley-node--component"><circle cx="691.2" cy="289.92" r="6" fill="white" stroke="#333333" stroke-width="1"></circle><text x="699.2" y="281.92" class="wardley-node-label" fill="#131300" font-size="10" font-weight="normal" text-anchor="start" dominant-baseline="auto">Hot Water</text></g><g class="wardley-node wardley-node--component"><circle class="wardley-buy-overlay" cx="329.4" cy="335.28" r="12" fill="#ccc" stroke="#333333" stroke-width="1"></circle><circle cx="329.4" cy="335.28" r="6" fill="white" stroke="#333333" stroke-width="1"></circle><text x="347.4" y="317.28" class="wardley-node-label" fill="#131300" font-size="10" font-weight="normal" text-anchor="start" dominant-baseline="auto">Kettle</text></g><g class="wardley-node wardley-node--component"><circle cx="610.8" cy="501.6" r="6" fill="white" stroke="#333333" stroke-width="1"></circle><text x="618.8" y="493.6" class="wardley-node-label" fill="#131300" font-size="10" font-weight="normal" text-anchor="start" dominant-baseline="auto">Power</text></g></g><g class="wardley-notes"><text x="441.96" y="400.8" text-anchor="start" font-size="11" fill="#131300" font-weight="bold">Standardising power allows Kettles to evolve faster</text></g></g><defs><marker id="arrow-w-dew9ffskc1s" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="#dc3545" stroke="none"></path></marker><marker id="link-arrow-end-w-dew9ffskc1s" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="5" markerHeight="5" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" fill="#333333" stroke="none"></path></marker><marker id="link-arrow-start-w-dew9ffskc1s" viewBox="0 0 10 10" refX="1" refY="5" markerWidth="5" markerHeight="5" orient="auto"><path d="M 10 0 L 0 5 L 10 10 z" fill="#333333" stroke="none"></path></marker></defs></svg>) Reading it back: coordinates are `[visibility, evolution]` — visibility on the Y axis (0 = invisible infrastructure, 1 = directly user-facing), evolution on the X axis (0 = genesis, 1 = commodity). Red dashed arrows come from `evolve`, which marks where a component is heading. Dependencies link the value chain downward: the business needs the cup of tea, which needs power — and power is already a commodity, which is why you never build it. Other strategy decorators — `(outsource)`, `(market)`, `(inertia)` — go in the same spot as `(build)`/`(buy)`. ### Wardley maps in practice: the quarterly build-vs-buy review[​](#wardley-maps-in-practice-the-quarterly-build-vs-buy-review "Direct link to Wardley maps in practice: the quarterly build-vs-buy review") A platform team walks into roadmap planning with three competing proposals for the same authentication work. Without a shared picture, the debate repeats every quarter. With a Wardley map on the space's tech-radar page, the argument settles in one glance: identity management sits far right (commodity — buy it, integrate it), while the usage-based pricing engine sits far left (genesis — nobody has productized this, building it *is* the differentiator). The map becomes the pre-read for the planning meeting; when a component evolves — say a vendor ships a solid feature-flag product — you move it and add an `evolve` arrow, and the page history shows *when* the strategy changed and why. That is the part a whiteboard photo can never do. ## Event modeling: the system-behavior timeline[​](#event-modeling-the-system-behavior-timeline "Direct link to Event modeling: the system-behavior timeline") Event modeling describes systems by how information flows through them — user interface, command, event, read model — usually drawn on a big whiteboard. Mermaid 12.3's `eventmodeling` type brings that workflow into text, with swimlanes inferred for you: ``` eventmodeling tf 01 ui CartUI tf 02 cmd AddItem tf 03 evt ItemAdded tf 04 rmo CartItems tf 05 ui CartUI ``` ![An event modeling flow: CartUI, AddItem, ItemAdded, CartItems, CartUI across the inferred swimlanes](data:image/svg+xml;base64,<svg id="n-1byazuvb46reventmodeling" width="100%" xmlns="http://www.w3.org/2000/svg" style="background-color: white; max-width: 100%; height: auto; max-width: 911px;" viewBox="-30 -30 911 470" role="graphics-document document" aria-roledescription="eventmodeling"><style>#n-1byazuvb46reventmodeling{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#n-1byazuvb46reventmodeling .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#n-1byazuvb46reventmodeling .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#n-1byazuvb46reventmodeling .error-icon{fill:#552222;}#n-1byazuvb46reventmodeling .error-text{fill:#552222;stroke:#552222;}#n-1byazuvb46reventmodeling .edge-thickness-normal{stroke-width:1px;}#n-1byazuvb46reventmodeling .edge-thickness-thick{stroke-width:3.5px;}#n-1byazuvb46reventmodeling .edge-pattern-solid{stroke-dasharray:0;}#n-1byazuvb46reventmodeling .edge-thickness-invisible{stroke-width:0;fill:none;}#n-1byazuvb46reventmodeling .edge-pattern-dashed{stroke-dasharray:3;}#n-1byazuvb46reventmodeling .edge-pattern-dotted{stroke-dasharray:2;}#n-1byazuvb46reventmodeling .marker{fill:#333333;stroke:#333333;}#n-1byazuvb46reventmodeling .marker.cross{stroke:#333333;}#n-1byazuvb46reventmodeling svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#n-1byazuvb46reventmodeling p{margin:0;}#n-1byazuvb46reventmodeling .node .neo-node{stroke:#9370DB;}#n-1byazuvb46reventmodeling [data-look="neo"].node rect,#n-1byazuvb46reventmodeling [data-look="neo"].cluster rect,#n-1byazuvb46reventmodeling [data-look="neo"].node polygon{stroke:#9370DB;filter:drop-shadow(1px 2px 2px rgba(185, 185, 185, 1));}#n-1byazuvb46reventmodeling [data-look="neo"].swimlane.cluster rect{filter:none;}#n-1byazuvb46reventmodeling [data-look="neo"].node path{stroke:#9370DB;stroke-width:1px;}#n-1byazuvb46reventmodeling [data-look="neo"].node .outer-path{filter:drop-shadow(1px 2px 2px rgba(185, 185, 185, 1));}#n-1byazuvb46reventmodeling [data-look="neo"].node .neo-line path{stroke:#9370DB;filter:none;}#n-1byazuvb46reventmodeling [data-look="neo"].node circle{stroke:#9370DB;filter:drop-shadow(1px 2px 2px rgba(185, 185, 185, 1));}#n-1byazuvb46reventmodeling [data-look="neo"].node circle .state-start{fill:#000000;}#n-1byazuvb46reventmodeling [data-look="neo"].icon-shape .icon{fill:#9370DB;filter:drop-shadow(1px 2px 2px rgba(185, 185, 185, 1));}#n-1byazuvb46reventmodeling [data-look="neo"].icon-shape .icon-neo path{stroke:#9370DB;filter:drop-shadow(1px 2px 2px rgba(185, 185, 185, 1));}#n-1byazuvb46reventmodeling :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g></g><g class="em-swimlane"><rect x="0" y="0" rx="3" width="851" height="130" fill="rgb(250,250,250)" stroke="rgb(240,240,240)"></rect><text font-weight="bold" x="30" y="30">UI/Automation</text></g><g class="em-swimlane"><rect x="0" y="140" rx="3" width="851" height="130" fill="rgb(250,250,250)" stroke="rgb(240,240,240)"></rect><text font-weight="bold" x="30" y="170">Command/Read Model</text></g><g class="em-swimlane"><rect x="0" y="280" rx="3" width="851" height="130" fill="rgb(250,250,250)" stroke="rgb(240,240,240)"></rect><text font-weight="bold" x="30" y="310">Events</text></g><g class="em-box"><rect x="250" y="15" rx="3" width="155" height="100" stroke="#dbdada" fill="white"></rect><foreignObject x="260" y="25" width="135" height="80"><div xmlns="http://www.w3.org/1999/xhtml" style="display: table; height: 100%; width: 100%;"><span style="display: table-cell; text-align: center; vertical-align: middle;"><b>CartUI</b></span></div></foreignObject></g><g class="em-box"><rect x="335" y="155" rx="3" width="172" height="100" stroke="#679ac3" fill="#bcd6fe"></rect><foreignObject x="345" y="165" width="152" height="80"><div xmlns="http://www.w3.org/1999/xhtml" style="display: table; height: 100%; width: 100%;"><span style="display: table-cell; text-align: center; vertical-align: middle;"><b>AddItem</b></span></div></foreignObject></g><g class="em-box"><rect x="437" y="295" rx="3" width="191" height="100" stroke="#c19a0f" fill="#ffb778"></rect><foreignObject x="447" y="305" width="171" height="80"><div xmlns="http://www.w3.org/1999/xhtml" style="display: table; height: 100%; width: 100%;"><span style="display: table-cell; text-align: center; vertical-align: middle;"><b>ItemAdded</b></span></div></foreignObject></g><g class="em-box"><rect x="558" y="155" rx="3" width="183" height="100" stroke="#a3b732" fill="#d3f1a2"></rect><foreignObject x="568" y="165" width="163" height="80"><div xmlns="http://www.w3.org/1999/xhtml" style="display: table; height: 100%; width: 100%;"><span style="display: table-cell; text-align: center; vertical-align: middle;"><b>CartItems</b></span></div></foreignObject></g><g class="em-box"><rect x="671" y="15" rx="3" width="155" height="100" stroke="#dbdada" fill="white"></rect><foreignObject x="681" y="25" width="135" height="80"><div xmlns="http://www.w3.org/1999/xhtml" style="display: table; height: 100%; width: 100%;"><span style="display: table-cell; text-align: center; vertical-align: middle;"><b>CartUI</b></span></div></foreignObject></g><path class="em-relation" fill="none" stroke="#333333" stroke-width="1" marker-end="url(#em-arrowhead-n-1byazuvb46reventmodeling)" d="M353.3333333333333 115 L392.3333333333333 155"></path><path class="em-relation" fill="none" stroke="#333333" stroke-width="1" marker-end="url(#em-arrowhead-n-1byazuvb46reventmodeling)" d="M449.6666666666667 255 L500.6666666666667 295"></path><path class="em-relation" fill="none" stroke="#333333" stroke-width="1" marker-end="url(#em-arrowhead-n-1byazuvb46reventmodeling)" d="M564.3333333333334 295 L619 255"></path><path class="em-relation" fill="none" stroke="#333333" stroke-width="1" marker-end="url(#em-arrowhead-n-1byazuvb46reventmodeling)" d="M680 155 L722.6666666666666 115"></path><defs><marker id="em-arrowhead-n-1byazuvb46reventmodeling" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto"><polygon points="0 0, 10 3.5, 0 7" fill="#333333"></polygon></marker></defs></svg>) Each `tf` (time frame) gets a unique number and an entity type: `ui`, `cmd` (command), `evt` (event), `rmo` (read model) or `pcr` (processor). Entities land in the UI/Automation, Command/Read Model and Events swimlanes automatically, and the flow between frames is inferred — so you sketch the timeline and mermaid wires it. When inference guesses wrong, a reset frame (`rf 04 evt ...`) breaks the chain, and `->>` reconnects frames explicitly. ### Event modeling in practice: design sessions that survive the meeting[​](#event-modeling-in-practice-design-sessions-that-survive-the-meeting "Direct link to Event modeling in practice: design sessions that survive the meeting") An order-fulfillment feature kicks off with a two-hour design session: what does the customer see, what command does it trigger, what event fires, what read model does the next screen need? In the room, that is a whiteboard. The problem starts when the meeting ends — the photo lands in a page, nobody can comment on a specific step, and three sprints later the implemented behavior has quietly drifted. Typed into Confluence with `eventmodeling`, every frame is a reviewable line: the product reviewer asks about `tf 03` in page comments, the engineer edits `tf 05` when the design changes, and the diff shows up in page history. A `pcr` frame marks pure processing (no UI), and an `rf` reset marks manual steps where automatic inference would guess wrong — exactly the spots a reviewer needs to look at. ## BPMN shapes: process notation without the plugin[​](#bpmn-shapes-process-notation-without-the-plugin "Direct link to BPMN shapes: process notation without the plugin") The other headline in 12.3: flowchart nodes can now be rendered as genuine BPMN notation. The full shape catalog, in one process: ``` %% bpmn-start: thin circle · bpmn-intermediate/boundary: double circles %% bpmn-end: thick circle · bpmn-gateway: diamond · bpmn-activity: task box %% bpmn-data: document · bpmn-data-store: cylinder · bpmn-annotation: bracket flowchart TB start@{ shape: bpmn-start, label: "Start" } task@{ shape: bpmn-activity, label: "Do work" } bound@{ shape: bpmn-boundary, label: "Timeout" } mid@{ shape: bpmn-intermediate, label: "Message in" } gw@{ shape: bpmn-gateway, label: "OK?" } data@{ shape: bpmn-data, label: "Doc" } store@{ shape: bpmn-data-store, label: "DB" } ann@{ shape: bpmn-annotation, label: "SLA 24h" } endN@{ shape: bpmn-end, label: "End" } start --> task task -.-> bound bound -.-> task task --> mid mid --> gw gw -->|yes| endN gw -->|no| task task --> data data --> store ann -.-> task ``` ![A BPMN process flow with all nine shapes: start and end events, a boundary and intermediate event, a gateway, an activity, a data object, a data store and an annotation](/assets/images/bpmn-e43a44ee7a27a3f7cf846b5c08fed04e.svg) Edges stay standard flowchart arrows, so existing flowchart habits carry over. And because they are ordinary flowchart edges, BPMN processes can also use the step animation from the next section. ### BPMN in practice: refund processes auditors can read[​](#bpmn-in-practice-refund-processes-auditors-can-read "Direct link to BPMN in practice: refund processes auditors can read") Refund and chargeback handling is the classic case: support knows the steps, finance knows the controls, and the audited "official process" lives in a Visio export nobody has opened since last year's audit. Drawn with BPMN shapes in Confluence, the same process becomes maintainable text — the gateway is a real diamond, timeouts are `bpmn-boundary` events hanging off the activity, the SLA note is a `bpmn-annotation`, and the system of record is a `bpmn-data-store`. An external auditor reads the notation without a legend; an ops engineer updates the gateway condition in four lines of text after the policy change; and because it renders from source, the page always shows the process as it actually is — not as it was in the screenshot. The same pattern works for SOPs, onboarding checklists, and any flow where "which symbol is which" carries meaning. ## Animated flows: a walkthrough that plays itself[​](#animated-flows-a-walkthrough-that-plays-itself "Direct link to Animated flows: a walkthrough that plays itself") The other 12.3 headline is step animation for flowchart edges. Give each edge an id, then number the steps: ``` %% name each edge with an id: nodeId@--> ; set the play order with id@{ step: N } flowchart LR Requester e1@--> Approval Approval e2@--> Finance Finance e3@-->|approved| Payment Payment e4@--> Requester e1@{ step: 1 } e2@{ step: 2 } e3@{ step: 3 } e4@{ step: 4 } ``` ![An animated approval loop: Requester, Approval, Finance, Payment with edges highlighted in step order](/assets/images/animated-flow-f54beac928f9317490bd0e9b03e10509.svg) In the editor and on the page, the edges highlight in step order while a dot travels along the active one — the image above is the animated SVG itself, so if it is moving in your browser, that is exactly what a Confluence reader sees. Readers with reduced-motion preferences get a static diagram automatically, and `flowchart.stepDuration` (milliseconds per step, set in the YAML frontmatter at the top of the code) tunes the pace. ### Animated flows in practice: runbooks that point at the next step[​](#animated-flows-in-practice-runbooks-that-point-at-the-next-step "Direct link to Animated flows in practice: runbooks that point at the next step") Picture the two audiences where this pays off immediately. **New hires** onboarding into a request-approval-payment workflow don't squint at ten arrows wondering where to start — the diagram plays the happy path in order, and the loop from Payment back to Requester explains itself. **Incident responders** at 3 a.m. get a runbook diagram whose escalation path walks itself: detection → page the on-call → mitigate → communicate, each edge lighting up in sequence, with branch edges (rollback vs. hotfix) waiting un-highlighted until relevant. Because the animation is part of the rendered SVG on the page — not a video to maintain — the runbook stays a normal Confluence page that edits as text. ## Agent flows: document AI agent workflows as text[​](#agent-flows-document-ai-agent-workflows-as-text "Direct link to Agent flows: document AI agent workflows as text") Agent diagrams are no longer an afterthought. `agentflow-beta` (new since Mermaid 12.0, and now a template in the app) draws agentic workflows — one `flow` block per agent, typed steps inside, and `connector` blocks for the external systems the agent talks to: ``` agentflow-beta TB %% one flow block per agent; the shaded group is the agent itself %% type each step as input (parallelogram), task (rounded box) or tool (boxed bar) flow reviewer["Review Agent"] changes["Gather changes"]@{ shape: input } analyse["Analyse"]@{ shape: task } lint["run_linter"]@{ shape: tool } changes --> analyse --> lint end %% connector: an external system or human in the loop; edges and edge %% labels (-->|approved|) work exactly as in flowcharts connector ext["External system"] reviewer -->|approved| ext ``` ![An agent flow diagram: a Review Agent flow block with input, task and tool steps, connected to an external system](/assets/images/agentflow-0fa409f8e240b3e3f60e938dbeb330c6.svg) This is the shape of a code-review agent: gather the changes, analyse them, call the linter tool, and — once approved — hand the result to an external system. When the workflow changes, you edit four lines of text instead of re-drawing a swimlane diagram. ### Agent flows in practice: the security review conversation[​](#agent-flows-in-practice-the-security-review-conversation "Direct link to Agent flows in practice: the security review conversation") Before an AI agent ships, someone has to answer hard questions: what data does it read, which tools does it call, what leaves the boundary, where is the human approval? With slides, those answers are stale the week after the demo. With an agent flow on the Confluence page, the security review has an artifact to point at: the `flow` block is the agent's boundary, `@{ shape: tool }` steps are exactly the actions it can take, and `connector` blocks are the systems it hands off to — reviewers sign off per connector, not per slide. The same page then serves as the agent's living documentation: when the workflow gains a step, the diff in page history shows the boundary change, which is precisely what an AI-governance review wants to see. ## What your existing diagrams will do[​](#what-your-existing-diagrams-will-do "Direct link to What your existing diagrams will do") Nothing dramatic, by design. The 12.3 engine upgrade is backward compatible syntactically — your flowcharts, sequence diagrams, gantt charts and mind maps keep rendering as before. What you may notice: * **Diagrams upgrade themselves** — the macro re-renders with the new engine the next time the page is viewed, and the refreshed SVG is cached on the next edit. No migration, no action. * **Swimlane and ELK routing fixes** land with 12.3, so some lane diagrams may route their edges more cleanly than before. * **Use case include/extend labels** now render with proper UML guillemets (`«include»`). ## Where to find the new templates[​](#where-to-find-the-new-templates "Direct link to Where to find the new templates") | App | Where | | ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | | [Mermaid Plus Diagrams & AI Agent for Confluence](https://marketplace.atlassian.com/apps/1236814/mermaid-plus-diagrams-ai-agent-for-confluence/) | Insert the macro → **Quick Templates** panel → Wardley / Event Modeling / BPMN / Animated Flow / Agent Flow, or the Help modal for syntax examples | | [Enhanced Markdown for Confluence](https://marketplace.atlassian.com/apps/1237026/enhanced-markdown-for-confluence/) | Type a ` ```mermaid ` fence with `wardley-beta`, `eventmodeling`, `agentflow-beta` or a `@{ shape: bpmn-… }` flowchart | The Rovo AI agent in Mermaid+ knows every Mermaid v12 diagram type, so you can ask for a Wardley map in chat and have it inserted onto the page directly. ## Related posts[​](#related-posts "Direct link to Related posts") * [Mermaid 12 in Confluence & Jira: UML use case diagrams and a new look](/blog/mermaid-12-confluence-jira.md) * [UML use case diagrams in Confluence](/blog/uml-use-case-diagram-confluence.md) * [Mermaid vs PlantUML vs Graphviz in Confluence](/blog/mermaid-vs-plantuml-vs-graphviz-confluence.md) Try Mermaid Plus Diagrams & AI Agent for Confluence All 30 Mermaid diagram types plus a Rovo AI agent, with live preview and one-click templates — free for up to 10 users. [Get it on the Atlassian Marketplace](https://marketplace.atlassian.com/apps/1236814/mermaid-plus-diagrams-ai-agent-for-confluence?utm_source=ngpilot.com\&utm_medium=website\&utm_campaign=mermaid-plus-for-confluence) ## Related guides * [How to Create Mermaid Diagrams in Jira](/blog/how-to-create-mermaid-diagrams-jira.md) * [Export Jira Issues to Excel or CSV](/blog/export-jira-issues-to-excel.md) * [Bulk Download Jira Attachments](/blog/bulk-download-jira-attachments.md) * [How to Migrate Confluence Content](/blog/how-to-migrate-confluence-content.md) * [How to Add a Block Quote in Confluence](/blog/block-quote-confluence.md) Explore NGPILOT[Browse Solutions](/solutions.md)[All Apps](/apps.md)[All Posts](/blog/archive.md)[Atlassian Marketplace →](https://marketplace.atlassian.com/vendors/1226848/?utm_source=ngpilot.com\&utm_medium=blog\&utm_campaign=hub-links) **Tags:** * [confluence](/blog/tags/confluence.md) * [mermaid](/blog/tags/mermaid.md) * [diagrams](/blog/tags/diagrams.md) * [release-notes](/blog/tags/release-notes.md) * [wardley-map](/blog/tags/wardley-map.md) * [event-modeling](/blog/tags/event-modeling.md)