AI process mapping tools, ranked
We gave seven AI process-mapping tools the same three prompts, a procure-to-pay request, a messy support-call transcript, and a set of supplier-invoice rules, and had an impartial AI agent score every result on a fixed rubric (process-map quality, speed, value, ease). Below is the ranking, with every diagram, so you can check the work.
By Jack Finnegan · Updated 12 June 2026
Two tools produced the clearest, most complete maps
- BA Copilot (4.76) and Eraser (4.58) led the field. They were the only two to get the whole picture right on every prompt, who does each step, every decision, every loop, and the handoffs between teams, laid out cleanly enough to hand straight to a colleague. (In process-mapping terms, that’s a true BPMN swimlane diagram, but you don’t need to know BPMN to see the difference.)
- BA Copilot took the top spot: its first usable map arrives in seconds, the fastest in the field, while keeping the strongest BPMN. Eraser is close behind on equally strong diagrams.
- Mermaid Chart (4.09) and Excalidraw (4.07) follow with strong, complete flowcharts and fully exposed source, they capture the steps and decisions well, but don’t separate who’s responsible for what as cleanly.
- Lucidchart (3.92) makes genuine swimlanes but with a more cluttered, higher-friction workflow; Whimsical (3.83) and Miro (3.61) produce clean, connected flowcharts.
Weights: process-map quality 50%, generation speed 25%, value for money 15%, ease of use 10%. Scored from the diagrams alone, by an impartial agent.
The full ranking, weighted out of 5
Benchmarked tools only: each produced prompts A, B and C in the same run.
| # | Tool | Quality 50% | Speed 25% | Value 15% | Ease 10% | Weighted | Output type |
|---|---|---|---|---|---|---|---|
| 🥇 | BA Copilot | 5.0 | 5.0 | 4.0 | 4.1 | 4.76 | True BPMN swimlanes |
| 🥈 | Eraser | 4.9 | 4.8 | 4.3 | 2.9 | 4.58 | True BPMN swimlanes |
| 🥉 | Mermaid Chart | 4.2 | 4.3 | 4.0 | 3.2 | 4.09 | Flowchart (C = swimlanes); full source |
| 4 | Excalidraw | 3.6 | 5.0 | 4.2 | 3.9 | 4.07 | Flowchart w/ subgraphs; full source |
| 5 | Lucidchart | 4.3 | 4.5 | 3.0 | 2.0 | 3.92 | True swimlanes |
| 6 | Whimsical | 3.9 | 3.5 | 4.0 | 4.0 | 3.83 | Connected flowchart |
| 7 | Miro | 3.8 | 3.3 | 3.9 | 3.0 | 3.61 | Flowchart, colour-coded actors |
BA Copilot and Eraser lead because they were the only tools to produce true BPMN swimlanes for all three prompts. The weighted score is the sum of each criterion times its weight.
Observed generation time
Seconds from prompt submit to the diagram first appearing complete, across all three prompts.
| Tool | A · Procure-to-Pay | B · Transcript | C · Rules | Total |
|---|---|---|---|---|
| BA Copilot | ~8 | ~12 | ~13 | ~33 |
| Excalidraw | ~18 | ~20 | ~22 | ~60 |
| Eraser | ~18 | ~25 | ~22 | ~65 |
| Lucidchart | ~20 | ~30 | ~25 | ~75 |
| Mermaid Chart | ~25 | ~26 | ~30 | ~81 |
| Whimsical | ~35 | ~30 | ~40 | ~105 |
| Miro | ~35 | ~40 | ~35 | ~110 |
Speed is scored on time to the first usable process map. BA Copilot surfaces a complete, concise BPMN map in ~8–13s per prompt (≈33s total, the fastest in the field), and gives you three layouts to choose from rather than one draft.
How it was run, and the three prompts
Every tool received the same three prompts, in order A → B → C, using its most diagram-appropriate AI mode (e.g. Eraser “BPMN”, Whimsical “Flowchart”, Excalidraw “Text to diagram”, Mermaid “Generate”, Miro AI Sidekick). Where a tool exposed source (Mermaid, Excalidraw), it was captured verbatim.
Only tools that offer a free tier could be included in this benchmark. If you’re a vendor and want your tool included, email support@ba-copilot.com and tell us how we can access it to run the benchmark.
A: Procure-to-Pay (tests inference from a terse request)
Create a procure-to-pay process map.
B: Customer Support Escalation transcript (tests extraction from messy spoken source)
An interview transcript to be turned into a process map capturing who does each task, the handoffs, decision points, loops, exceptions and final resolution paths.
C: Supplier Invoice Approval from plain-English rules (tests faithful rule-following, no invented steps)
Explicit rules with amount-based routing (<$1k automatic / $1k–$10k manager / >$10k Finance Director), approve / reject / clarify branches, clarification-back-to-the-same-reviewer loops, and defined completion outcomes.
What the prompts revealed
- Inference (A): BA Copilot, Mermaid, Whimsical, Excalidraw and Miro all inferred a credible P2P process from the terse prompt. Lucidchart and Eraser asked clarifying questions instead of inferring.
- Extraction (B): Mermaid Chart produced the most complete single capture (a 59-line flowchart with every loop). Eraser rendered it as a clean 4-lane BPMN. BA Copilot, Whimsical, Excalidraw and Miro also captured the exception paths.
- Rule-following (C): BA Copilot, Eraser (swimlanes), Mermaid (swimlanes), Whimsical, Miro, Lucidchart and Excalidraw all reproduced the amount-based routing and the clarification loop without inventing steps.
Per-tool results & evidence
Each tool’s prompt-A diagram (procure-to-pay) leads, with prompts B and C shown below it. Prompt C is the strictest test (amount routing plus review loops). Click any diagram to view it full size.
🥇BA Copilot
True multi-lane BPMN for all three prompts, with the strongest formal process-map semantics of any tool tested, and the fastest to a usable map: a complete, concise BPMN diagram in seconds (≈8–13s per prompt). Prompt C produced five lanes (Supplier / Accounts Payable / Relevant Manager / Finance Director / Finance Team) carrying the amount-based routing and the approve / reject / clarify loops, all exportable as BPMN 2.0 XML. You also get three options per prompt to choose the best layout.
Prompts B & C
🥈Eraser
Eraser’s free AI diagram generator (DiagramGPT) produced true multi-lane BPMN, pools and lanes, gateways, start / end events and message flows, for all three prompts. Prompt C resolved into five lanes with the amount-based routing and clarification loop intact, the cleanest formal BPMN of the field. The terse prompt A drew a clarifying-questions step rather than an immediate inference.
Prompts B & C
🥉Mermaid Chart
Consistent and fully transparent: every diagram is backed by verbatim Mermaid source. Prompt B was the single most complete transcript capture of any tool, a flowchart that caught every loop; Prompt C resolved into true swimlanes via per-actor subgraphs with the amount-based routing intact. Output is a flowchart for A and B, formal swimlanes for C.
Prompts B & C
4Excalidraw
The fastest tool, and fully transparent via verbatim Mermaid source. The logic is strong: phase subgraphs on A, team subgraphs on B, and correct amount-based routing with clarification loops on C. The output is a flowchart with subgraph grouping in Excalidraw’s hand-drawn style rather than formal BPMN swimlanes, which is why it scores below the BPMN tools on map quality.
Prompts B & C
5Lucidchart
Produces genuine swimlane process maps: Prompt C even added a documentation header and diagram key. The map quality is high, but the workflow carries more friction than the rest, and the terse prompt A drew a clarifying gate rather than an inference. A high ceiling on output paired with a busier workflow.
Prompts B & C
6Whimsical
Clean, connected flowcharts for all three prompts, with full branching and loops (Prompt A ran to 53 elements; Prompt C to 56, carrying the amount-based routing and review loops). The output is a well-organised flowchart rather than formal BPMN swimlanes.
Prompts B & C
7Miro
Miro’s AI Sidekick generated solid connected flowcharts for all three prompts, with actors distinguished by colour and full branching and loops: Prompt C captures the amount-based routing, review loops and approve / reject / close outcomes. The output is a flowchart with colour-coded actors rather than formal BPMN swimlanes.
Prompts B & C
Scoring rubric & weighted math
Each benchmarked tool was scored 1–5 on four criteria, then weighted: process-map quality ×0.50 + generation speed ×0.25 + value for money ×0.15 + ease of use ×0.10.
| Tool | Weighted math | Result |
|---|---|---|
| BA Copilot | 5.0 × .50 + 5.0 × .25 + 4.0 × .15 + 4.1 × .10 | 4.76 |
| Eraser | 4.9 × .50 + 4.8 × .25 + 4.3 × .15 + 2.9 × .10 | 4.58 |
| Mermaid Chart | 4.2 × .50 + 4.3 × .25 + 4.0 × .15 + 3.2 × .10 | 4.09 |
| Excalidraw | 3.6 × .50 + 5.0 × .25 + 4.2 × .15 + 3.9 × .10 | 4.07 |
| Lucidchart | 4.3 × .50 + 4.5 × .25 + 3.0 × .15 + 2.0 × .10 | 3.92 |
| Whimsical | 3.9 × .50 + 3.5 × .25 + 4.0 × .15 + 4.0 × .10 | 3.83 |
| Miro | 3.8 × .50 + 3.3 × .25 + 3.9 × .15 + 3.0 × .10 | 3.61 |
Quality anchors: 5 = complete and correctly structured, shows who owns each step (in lanes), every decision, branch, loop and join, with all the right actors (i.e. a true BPMN swimlane diagram); 3 = a mostly-correct flowchart that captures the steps but not who’s responsible for what; 1 = generic / unusable. Value: 5 = strong value at the tested volume; 1 = payment required before meaningful testing. Ease: 5 = stable prompt-to-map; 1 = fragile / manual recovery.
Speed is scored on the time to the first usable process map: speed = 5 − (total seconds − 60) / 30, capped at 5.0, so the speed score tracks the time each tool actually took. BA Copilot surfaces a complete map in ~8–13s per prompt (≈33s total, the fastest in the field).
Fairness, transparency & how to reproduce it
This comparison was scored by an impartial AI agent, working only from the diagrams each tool produced and the submit-to-complete timings above. The agent applied the fixed weighted rubric uniformly; it did not score from brand reputation, prior runs, or anyone’s expectations. Every verdict is auditable: the diagram that earned each score is shown right next to it.
BA Copilot and Eraser led the field because they were the only tools to natively produce true BPMN swimlanes across all three prompts, which you can verify directly from their diagrams above.
Run it yourself: give this prompt to your own AI agent
Don’t take our word for it. Paste the prompt below into your own AI agent (or run it by hand). It defines the exact tools, prompts and rubric, so an independent agent reaches its own verdict.
You are an impartial benchmarking agent. Independently evaluate AI process-mapping tools and rank them, do not rely on any existing review, brand reputation, or my opinion. Score only from what each tool actually produces in your run. TOOLS (use each tool's most diagram/BPMN-appropriate AI mode; skip any that needs payment, and record why): BA Copilot, Eraser (free public AI BPMN generator at eraser.io/ai/bpmn-diagram-generator), Mermaid Chart, Whimsical, Excalidraw, Miro, Lucidchart. PROMPTS: send all three to every tool, verbatim, in order. These are the exact prompts used. === Prompt A === Create a procure-to-pay process map. === Prompt B === Turn the following transcript into a process map. Capture who does each task, the handoffs between people or teams, the decision points, loops, exceptions, and the final resolution paths. Transcript title: Customer Support Escalation Transcript Interviewer: Walk me through what happens when a customer reports a serious product issue. Support Lead: The customer usually comes in through chat or email. A support agent first checks whether the customer has an active account and asks for the workspace, browser, screenshots, and steps to reproduce. If the issue is just a how-to question, the agent answers it and closes the ticket. Interviewer: What if it looks like a bug? Support Lead: The agent tries to reproduce it. If they cannot reproduce it, they ask the customer for more detail and keep the ticket open. If they can reproduce it, they tag it as a bug and check severity. Interviewer: How do you decide severity? Support Lead: If the customer is blocked from completing important work or data may be wrong, it becomes high severity. Otherwise it stays normal severity. Interviewer: What happens for normal severity? Support Lead: The agent creates a product ticket, links the support conversation, tells the customer we have logged it, and adds it to the normal triage queue. Product reviews it during the next triage session and either schedules it, asks support for more evidence, or closes it as expected behavior. Interviewer: And high severity? Support Lead: The agent escalates to the engineering on-call person and posts in the incident channel. Engineering confirms whether it is a live defect. If it is not a live defect, the ticket goes back to normal support follow-up. If it is live, engineering starts a fix or workaround. Interviewer: Who talks to the customer while that is happening? Support Lead: Support sends an acknowledgement and gives updates every hour for high severity issues. If engineering provides a workaround, support sends it to the customer and checks whether it unblocks them. Interviewer: What if the workaround does not help? Support Lead: Then support keeps the escalation open and engineering continues work on a fix. Once a fix is deployed, engineering tells support, support asks the customer to confirm, and if the customer confirms, support closes the ticket. If the customer says it is still broken, it goes back to engineering with the new details. Interviewer: Anything else? Support Lead: If the issue affected several customers, product writes a short post-incident note and support sends it to affected accounts before final closure. === Prompt C === Create a process map from these rules. Show the people or teams responsible for each activity, the order of work, the handoffs, the conditions that change the route, any repeated review loops, and the possible completion outcomes. Do not add steps that are not stated here. The supplier sends an invoice to Accounts Payable. Accounts Payable records the invoice, checks that a purchase order exists, and checks that the goods or services were received. If either check fails, Accounts Payable sends the invoice back to the supplier with the reason and waits for a corrected invoice. If the checks pass, Accounts Payable looks at the invoice amount. Invoices under $1,000 are scheduled for payment automatically. Invoices from $1,000 to $10,000 are sent to the relevant manager for review. Invoices over $10,000 are sent to the Finance Director for review. The reviewer can approve, reject, or ask for clarification. If clarification is needed, Accounts Payable gathers the missing information and sends the invoice back to the same reviewer. If the reviewer rejects the invoice, Accounts Payable records the rejection, notifies the supplier, and closes the case. If the reviewer approves the invoice, Accounts Payable schedules payment. On the scheduled payment date, Finance executes the payment. Accounts Payable then notifies the supplier, archives the invoice record, and marks the work complete. FOR EACH TOOL: start a timer at submit, stop when the diagram is complete; capture a clean screenshot and any exposed source; note fidelity gaps vs the prompt. SCORE each tool 1–5 and weight: process-map quality 50%, generation speed 25%, value for money 15%, ease of use 10%. Quality anchors: 5 = true BPMN/swimlanes (ownership lanes, start/end, gateways, loops, joins, all required actors); 3 = mostly-correct flowchart but not swimlanes/BPMN; 1 = generic/unusable. OUTPUT: a ranked table, the weighted math, and one screenshot per tool as evidence. Rank only tools that produced all three maps in the same run. Be impartial, let the artifacts decide.
Disclosure: this run was operated by the BA Copilot team, but the scoring was delegated to an impartial agent against the fixed rubric above. BA Copilot topped a benchmark it also ran, so judge the diagrams for yourself: a free competitor, Eraser, landed a very close second on equally strong BPMN. If you reproduce it and get a different ranking, we’d genuinely like to see it.
Frequently asked questions
Which AI tool builds the best process map?
Two tools, BA Copilot (weighted 4.76) and Eraser (4.58), produced the clearest, most complete maps: they correctly captured who does each step, the decisions, the branches and the loops, laid out in lanes that make the handoffs between teams obvious. (For the technically minded, they were the only two to output true BPMN swimlanes.) BA Copilot edged ahead on speed: its first usable map appears in seconds, while keeping that completeness; Eraser is close behind on equally strong diagrams.
How were the tools scored, and by whom?
Scoring was delegated to an impartial AI agent that judged only from the diagrams each tool produced and the submit-to-complete timings, against a fixed weighted rubric: process-map quality 50%, generation speed 25%, value for money 15%, ease of use 10%. It did not score from brand reputation, prior runs, or anyone’s expectations.
Can I reproduce this benchmark myself?
Yes. The Fairness & reproducibility section includes a copy-paste prompt you can hand to your own AI agent (or run by hand). It defines the exact tools, the three prompts and the weighted rubric, so an independent agent reaches its own verdict. If you get a different ranking, we’d genuinely like to see it.
What do the generation timings measure?
Each timer starts the instant the prompt is submitted and stops when the first usable process map is observed complete. Speed is scored on this time-to-first-usable-map, mapped onto a 5-point scale. BA Copilot surfaces a complete map in ~8–13s per prompt (≈33s total, the fastest in the field).
Caveats & honest limitations
- This was a single run. AI output varies between generations; scores reflect what these prompts produced on 12 Jun 2026, not a statistical average.
- Free tier only. Every tool was tested on its free tier, no paid upgrades. Tools without a free tier could not be included.
- Disclosure: this benchmark was operated by the BA Copilot team; the scoring was delegated to an impartial agent using the fixed rubric. BA Copilot and Eraser led the field because they were the only tools to natively produce true BPMN swimlanes across all three prompts, verifiable from the diagrams above.
Map your process with true BPMN, not just a flowchart
BA Copilot was one of only two tools in this benchmark to produce true BPMN swimlanes: pools, lanes, gateways and message flows from a plain-English prompt. Generate three options per request, then refine and export to BPMN.