Create flowcharts, mind maps, sequence/ER/UML diagrams and charts as editable, presentable boards.
Scored across 8 tools
The core split of create_diagram vs edit_diagram vs render_diagram (make new / modify existing / convert Mermaid text to an image) is clearly explained, and list_templates/open_template are cleanly paired. Minor overlap remains between create_diagram and code_to_flowchart (both produce flowcharts, one from prose and one from code) and between create_sop and create_diagram, which also draws the process, but descriptions steer the choice well.
Every name follows the same verb_noun snake_case pattern (create_diagram, edit_diagram, list_templates, open_template, render_diagram, simulate_process, code_to_flowchart, create_sop). No mixing of camelCase, casing variants, or bare-noun names.
Eight tools cover distinct stages of one workflow — authoring, editing, templates, rendering, documentation and simulation — with no redundant entries. Each tool has a clear reason to exist at this scope.
The lifecycle is largely covered: create, edit, template discovery/instantiation, image export, SOP generation and process simulation. Gaps are minor — there is no way to inspect a diagram's existing structure or delete/manage diagrams, but links returned by earlier calls let agents work around this.
Turn source code (C, C++, Java, Python or JavaScript, up to 80 lines) into a lab-record style flowchart where every box is linked to its code lines, plus a step-by-step dry run for a sample input (current line, box and variables at each step). Returns a link that opens it ready to play (▶ Explain), the program output and Mermaid code. Uses 1 AI credit.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | The program or function, as source code. | |
| language | No | Optional; detected if left out. | |
| sample_input | No | Optional input for the dry run, e.g. "n = 5". Picked automatically if left out. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnly=false, openWorld=true, idempotent=false, destructive=false. The description goes further, disclosing the returned artifacts (a ready-to-play link, the program output, Mermaid code) and the 1-credit cost. It stops short of saying whether the generated link is public or persists, which for an openWorldHint=true tool would be worth stating.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core transformation and then the output artifacts and cost. Dense but each clause carries information (languages, line cap, deliverables, credit cost) with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description compensates by enumerating the return payload (link, output, Mermaid code). Combined with the language list, size cap, optional-param auto-detection and credit cost, an agent has everything needed to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3; the description adds the 80-line limit on `code` and frames `sample_input` as feeding the dry run ('current line, box and variables at each step'), which sharpens what that optional param actually controls beyond the schema's terse 'Input for the dry run.'
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb+resource with scope: 'Turn source code ... into a lab-record style flowchart' with every box linked to its code lines, plus a dry run. It names the supported languages and the 80-line cap, so an agent can immediately tell this apart from the generic sibling create_diagram.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The input type (source code) makes the trigger condition clear, and the 'Uses 1 AI credit' note is a useful cost signal for deciding when to spend it. However, it never explicitly contrasts itself with create_diagram or the template tools, so routing between siblings is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a diagram in AI Flowchart from a plain-English description and get a link that opens it as an editable board (edit, present as an animated slideshow, export PNG/PDF/PowerPoint). Flowcharts, sequence diagrams and mind maps also come back as Mermaid code. Types: flowchart, mindmap, sequence (API / login flows), erdiagram (database), systemdesign (architecture), swimlane, bpmn (BPMN 2.0 business process), orgchart, uml_class, uml_usecase, uml_state, uml_activity, timeline, gantt (project plan), chart (bar/line/pie… from data you describe). Uses 1 AI credit; advanced types need AI Flowchart Pro.
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | Kind of diagram. | |
| description | Yes | What to draw, in detail: the process, system, data, steps or numbers. Include names and specifics from the conversation. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare non-readonly, open-world, non-idempotent behavior, so the bar is lower. The description still adds real context beyond them: the 1 AI credit cost, the Pro-tier requirement for advanced types, and what the output actually is (editable board, animated presentation, PNG/PDF/PowerPoint export, Mermaid for some types). It omits failure modes and rate limits, so not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core action and outcome, then a dense type catalogue. The long enum list earns its place because it disambiguates 15 values, though the sentence is heavily parenthesized and could be tighter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description correctly explains the return artifact (link/board/Mermaid) and the cost model. Annotations cover the safety profile. Minor gaps remain around input length limits or error behavior, but nothing an agent needs to invoke it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3, but the description goes beyond the raw enum by explaining what each type means (e.g. 'sequence (API / login flows)', 'erdiagram (database)', 'bpmn (BPMN 2.0 business process)'). It also reinforces the description parameter's intent to include names and specifics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Create a diagram in AI Flowchart from a plain-English description') plus the concrete payoff ('a link that opens it as an editable board'). The 'plain-English description' framing implicitly separates it from code_to_flowchart, which takes code as input.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when this tool applies (you have a textual description of a process/system/data) and enumerates the supported diagram types, which aids selection. However, it never explicitly says when to prefer this over code_to_flowchart or the template tools, nor states any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Write a standard operating procedure (SOP) for a business process: purpose, scope, roles and responsibilities, numbered steps with who does each one and what to do at each decision, and a RACI matrix. Use it when the user wants an SOP, work instruction, procedure document, process documentation, RACI or onboarding guide for a process. Pass a process diagram link from an earlier result (flowchart, swimlane or BPMN), or a description of the process and it is drawn first. The steps and roles always match the diagram. Returns the SOP as Markdown plus a link that opens it next to the diagram in AI Flowchart. Uses 1 AI credit.
| Name | Required | Description | Default |
|---|---|---|---|
| diagram | No | Link (https://aiflowchart.io/import/<id>) or id of a flowchart, swimlane or BPMN diagram made earlier. Leave out to use description. | |
| description | No | Only when there is no diagram yet: the process in detail — the steps in order, who does each (roles/teams), decisions and their outcomes. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations by disclosing the return format (Markdown plus an AI Flowchart link), a side effect (if only a description is passed, a diagram is drawn first), a consistency guarantee (steps and roles always match the diagram), and the cost ('Uses 1 AI credit'). The annotations already mark this as a non-read-only, open-world, non-idempotent write, and the description complements that with concrete operational consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the purpose and output contents, then moves to triggering conditions, input selection, and return/cost in a tight single paragraph. Every sentence carries actionable information; nothing is redundant with the title or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description correctly explains the return value (Markdown SOP plus a link that opens beside the diagram) and the cost/side-effect profile. For a 2-parameter optional-input tool, an agent has everything needed to decide and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are already documented in structured fields. The description adds only lightweight framing — that the diagram link should come from an earlier result and that description is the fallback — which largely restates what the schema says. Baseline 3 applies when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Write a standard operating procedure') and enumerates the exact sections produced (purpose, scope, roles, numbered steps, decisions, RACI matrix). This is clearly distinguishable from siblings like create_diagram or edit_diagram, which produce diagrams rather than prose documents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a rich trigger list — 'SOP, work instruction, procedure document, process documentation, RACI or onboarding guide' — plus an input-routing rule (diagram link from an earlier result vs. a description when none exists). It lacks an explicit when-NOT-to-use or a named sibling alternative for the diagram-only case, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Change a diagram made earlier in this chat with create_diagram: add, remove, rename or reconnect steps, shorten labels, recolour, restructure. Pass its link (https://aiflowchart.io/import/…) and the change in plain English. Use this instead of create_diagram whenever the user wants to adjust a diagram they already have, so their earlier work is kept. Returns a link to the new version plus Mermaid code where available. Uses 1 AI credit.
| Name | Required | Description | Default |
|---|---|---|---|
| diagram | Yes | The diagram link from an earlier result (https://aiflowchart.io/import/<id>) or just the id. | |
| instruction | Yes | What to change, e.g. "add a refund step after payment", "make the labels shorter", "remove the approval loop". |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false), the description discloses that the result is a new version rather than an in-place overwrite ("Returns a link to the new version plus Mermaid code where available") and that the call costs 1 AI credit. These are cost and output-shape facts not derivable from the structured fields, and the "new version" framing is consistent with destructiveHint=false.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, all front-loaded: capability first, inputs second, output/cost last. The operation list is dense but each item conveys a distinct capability rather than padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter mutation tool with no output schema, the description covers everything an agent needs: the required input format, the natural-language change instruction, the return value (link plus Mermaid where available), and the credit cost. No meaningful gap remains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are already documented; the description reinforces the diagram argument as the import link and stresses that the instruction is "plain English," which clarifies the expected natural-language input format. It adds modest meaning rather than new constraints, so it sits just above the baseline for fully covered schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb+resource ("Change a diagram made earlier in this chat") and enumerates the concrete operations available (add/remove/rename/reconnect steps, shorten labels, recolour, restructure). It explicitly contrasts with create_diagram, so an agent can distinguish it from siblings like render_diagram or code_to_flowchart without inspecting schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
States the selection rule outright: "Use this instead of create_diagram whenever the user wants to adjust a diagram they already have, so their earlier work is kept." It names the alternative tool and the condition that selects it, which is exactly what an agent needs to route correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List AI Flowchart's ready-made templates (lab programs, UML and ER for student projects, system designs, charts, app walkthroughs, code programs…). Free — no AI credits.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Optional board type to filter by, e.g. flowchart, erdiagram, sequence, mindmap, systemdesign, chart, codeflow, walkthrough. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety burden is met. The description adds genuinely new behavioral context: the call consumes no AI credits, which can drive agent decisions. It omits pagination and result-size behavior, so not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence naming the resource plus a short value tagline; the core purpose is front-loaded and nothing is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-argument list tool with full annotation coverage and no output schema, the description is sufficient — it names the resource, the category vocabulary, and the cost profile. Minor gaps are pagination and whether results are scoped to the user's workspace.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single optional 'type' filter is fully documented in the schema with enum-like examples, so the description need not repeat it. The category list in the description loosely maps to the filter values but adds no syntax beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (AI Flowchart's ready-made templates) and enumerates the template categories so an agent knows what comes back. It does not explicitly differentiate itself from the sibling open_template, but the list-vs-open distinction is inferable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use guidance, no prerequisites, and no reference to alternatives like open_template or create_diagram. The 'Free — no AI credits' note hints at when cost matters but is not framed as usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a link that opens one of the templates (from list_templates) as a new editable board. Free — no AI credits.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Template id from list_templates. | |
| type | Yes | Template type from list_templates. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds genuinely new context beyond them: the return value is a link, the effect is a new editable board, and the operation consumes no AI credits. Missing details are minor (whether the template itself is consumed, any auth requirement).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero waste, with the primary action and result front-loaded before the cost note. Nothing redundant with the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with no output schema and full annotation coverage, this is sufficient: the description supplies the return value (a link), the prerequisite (list_templates) and the cost profile. An agent has everything needed to select and call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and both parameters already say they come from list_templates, so the description's 'from list_templates' phrasing only reinforces the schema. No additional format or validation detail is offered, which is the expected baseline when the schema does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and outcome: get a link that opens a template as a new editable board. It also names the sibling that supplies the inputs (list_templates), so an agent can distinguish it from create_diagram and code_to_flowchart, which produce diagrams rather than link out to templates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clear context: this is the follow-up step to list_templates, and 'Free — no AI credits' signals the cost trade-off versus the AI-generating siblings. There is no explicit when-not or named alternative for other cases, which keeps it below a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Turn Mermaid diagram text into a hosted PNG and SVG image URL (cached on a CDN). Use it when a diagram has to go somewhere that cannot run Mermaid: email, Slack or Teams messages, PDFs, Word/Google Docs, Confluence, WhatsApp, a README. Returns the URLs plus ready-made Markdown and HTML. Free — no AI credits.
| Name | Required | Description | Default |
|---|---|---|---|
| style | No | "aiflowchart" (default) draws it in AI Flowchart's polished board style; "mermaid" gives the classic Mermaid look. Unsupported diagram types fall back to classic automatically. | |
| theme | No | Optional colour theme (default "default"). | |
| mermaid | Yes | Mermaid source, e.g. "flowchart TD\n A[Start] --> B{OK?}" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so safety is covered. The description adds genuinely new behavioral context: output is cached on a CDN, returns URLs plus ready-made Markdown and HTML, and is free with no AI credit consumption. It doesn't discuss failure modes for invalid Mermaid syntax, which is a minor gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler. The core capability is front-loaded, followed by the usage condition and return shape. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although there is no output schema, the description compensates by stating the return values (image URLs plus Markdown and HTML). Combined with annotations covering safety and a fully documented schema, an agent has everything needed to call this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, including enum explanations for style and theme, so the schema carries parameter meaning. The description adds nothing about style/theme selection; baseline 3 applies when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a concrete verb and resource: 'Turn Mermaid diagram text into a hosted PNG and SVG image URL.' The input type (Mermaid source) and output type (hosted images) are unambiguous. It does not explicitly name or contrast with similar siblings like create_diagram or code_to_flowchart, so sibling differentiation is left to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a clear, concrete when-to-use condition: destinations that cannot run Mermaid (email, Slack/Teams, PDFs, Word/Google Docs, Confluence, WhatsApp, README). It stops short of naming an alternative tool or stating when NOT to use it (e.g. when rendering locally or building a diagram interactively), so it is clear context without exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run a process diagram (flowchart, swimlane or BPMN made earlier) through AI Flowchart's process simulator — a real discrete-event simulation, not an AI guess — to find how long each case takes, the cost per case, how busy each team is and where the bottleneck is, with a suggestion. Use it when the user asks how long a process takes, where it gets stuck, how many staff they need, or what happens at a given volume. Pass the numbers the user gives (cases per day, people per team, minutes per step); anything missing uses clear defaults that are listed in the answer. Returns the results plus a link that opens the simulator on the diagram. Free — no AI credits.
| Name | Required | Description | Default |
|---|---|---|---|
| staff | No | People per lane/team, as the user said. Swimlanes: one entry per lane name. Flowcharts: a single entry for the whole team. | |
| diagram | Yes | Link (https://aiflowchart.io/import/<id>) or id of a flowchart, swimlane or BPMN diagram made earlier. | |
| step_minutes | No | How long steps take, in minutes of work, as the user said. Optional min/max for a range. | |
| cases_per_day | No | New cases (orders, tickets, claims…) arriving per working day. Default 20. | |
| cost_per_hour | No | Staff cost per hour, in the user's currency. Default 20. | |
| hours_per_day | No | Working hours per day. Default 8. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint=false, idempotentHint=true and destructiveHint=false; the description adds that this is a genuine discrete-event simulation rather than an AI estimate, that missing inputs fall back to defaults which are disclosed in the answer, that a simulator link is returned, and that the call costs no AI credits. Those are exactly the operational facts an agent cannot infer from the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads what the tool is and what it returns, then usage triggers, then input guidance and the return/cost note. It is dense but nearly every clause carries a distinct fact; the em-dash aside about 'not an AI guess' borders on marketing but does disambiguate behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With six parameters, one required, no output schema and no nested objects, the description covers the input policy (defaults), the return shape (results plus a simulator link) and the cost model. Nothing an agent needs in order to call it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so per-parameter meaning is already documented; the description adds the calling strategy, telling the agent to pass whatever numbers the user supplies and rely on disclosed defaults otherwise, which explains how to handle partially specified requests. It does not elaborate on the min/max range semantics for step_minutes beyond what the schema says.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: runs a flowchart/swimlane/BPMN diagram through a discrete-event process simulator and returns cycle time, cost per case, team utilization and bottleneck with a suggestion. That output set cleanly separates it from the sibling tools, which all create, edit, render or list diagrams rather than analyze them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit user-intent triggers: 'when the user asks how long a process takes, where it gets stuck, how many staff they need, or what happens at a given volume.' There is no when-not guidance or named alternative (e.g. use edit_diagram first if the diagram is wrong), so it falls short of the full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
create_sopedit_diagramsimulate_processrender_diagram1 field changedInput schema / properties / styleAdded value: +{
+ "description": "\"aiflowchart\" (default) draws it in AI Flowchart's polished board style; \"mermaid\" gives the classic Mermaid look. Unsupported diagram types fall back to classic automatically.",
+ "enum": [
+ "aiflowchart",
+ "mermaid"
+ ],
+ "type": "string"
+}render_diagramcreate_diagram1 field changedInput schema / properties / type / enumPrevious value: -[
- "flowchart",
- "mindmap",
- "sequence",
- "erdiagram",
- "systemdesign",
- "swimlane",
- "orgchart",
- "uml_class",
- "uml_usecase",
- "uml_state",
- "uml_activity",
- "timeline",
- "gantt",
- "chart"
-]New value: +[
+ "flowchart",
+ "mindmap",
+ "sequence",
+ "erdiagram",
+ "systemdesign",
+ "swimlane",
+ "bpmn",
+ "orgchart",
+ "uml_class",
+ "uml_usecase",
+ "uml_state",
+ "uml_activity",
+ "timeline",
+ "gantt",
+ "chart"
+]code_to_flowchartcreate_diagramlist_templatesopen_templateCreate, read and edit architecture, flow and ER diagrams on a live canvas shared with your team.
Create workflow, sequence, architecture, and mind map diagrams via AI assistants.
Create, edit and organize hand-drawn diagrams (flowcharts, ER, architecture) from any AI agent.
Create, edit, share and render real-time collaborative diagrams and mindmaps on livediagram.app.
Add one secure layer between your agents and this server.
