> ## Documentation Index
> Fetch the complete documentation index at: https://ai-kb.automationanywhere.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Visual and Python Workflows

> Choose Visual or Python workflows, use Autopilot in the editor, and read flowchart summaries

Modern EKB workflows come in two builder styles. You can create them yourself on the Tools canvas, or ask **Autopilot** (Build mode) to author them for you. This page covers how the two styles differ, how Autopilot fits in, and how to read the flowchart and summary views.

For the classic V1 vs V2 product lines and migration, see [Workflows overview](/tools/workflows-overview) and [Workflow Builder V2](/tools/workflows-v2).

## Visual vs Python at a glance

|                                    | **Visual** (Workflows v2)                                                | **Python** (Workflows v3 / code mode)                                                                                                          |
| ---------------------------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| **What you edit**                  | Drag-and-drop canvas of triggers, agents, tools, conditions, and outputs | Python source that defines the workflow logic                                                                                                  |
| **How you read it**                | Canvas graph                                                             | Readable **flowchart** with plain-English step labels, connected apps, and collapsible loop/branch cards — plus optional Developer (code) view |
| **Best for**                       | Processes you want to assemble and inspect visually                      | Logic that is easier to express in code, or that Autopilot should author end-to-end in Python                                                  |
| **Autopilot in the editor**        | Autopilot helps via chat / create-with-AI flows                          | Autopilot chat stays **docked on the canvas** while you build and refine                                                                       |
| **Manual “New Flow” / blank tool** | Default for manual creation                                              | Not the default for blank manual create (see below)                                                                                            |

A **Python** badge on a workflow in the Tools list means it is a code-mode (v3) workflow.

## Creating a workflow

### Build with Autopilot (recommended for either style)

1. Open your project (not the read-only Autopilot system project).
2. Use Autopilot in **Build** mode, or open **Tools** and start **Build workflow with AI** / the Autopilot create flow.
3. Describe what the workflow should do (you can attach files for context).
4. The create dialog shows whether Autopilot will build a **Workflows v3 / Python** or **Workflows v2 / Visual** workflow by default.
5. Autopilot plans, asks clarifying questions as needed, builds the workflow, and you can keep chatting to refine it.

<Tip>
  New Autopilot chats default to **Agent** mode. Switch to **Build** when you want Autopilot to create or change a workflow. See [Autopilot Modes](/autopilot/autopilot-modes).
</Tip>

**Who controls Visual vs Python for Autopilot creates?**\
A Super Admin setting — **Default new Autopilot workflows to Workflows v3** — chooses the default:

* **On** — Autopilot creates **Python / code mode** workflows by default
* **Off** — Autopilot creates **Visual (v2)** workflows by default

Manual blank workflow creation stays on the **Visual** builder.

### Create manually (Visual)

1. Go to **Tools**.
2. Use **New Flow** / create a blank custom tool.
3. Add a trigger, drag nodes onto the canvas, connect them, run, then publish.

Details: [Workflow Builder V2](/tools/workflows-v2).

## Autopilot-built workflows

When Autopilot builds a workflow in **Build** mode it typically:

1. Clarifies the trigger, steps, apps, and outputs
2. Creates the workflow in Visual or Python mode (per the platform default above)
3. Configures steps / Python source
4. Validates and tests where applicable
5. Hands you a summary of what was created

You can continue in the same chat: refine steps, fix failures, or switch to **Agent** mode to run or reason about the result without further authoring. See [How Autopilot Works](/autopilot/autopilot-how-it-works).

### Docked Autopilot in the editor

For **Python (code mode)** workflows, Autopilot stays **docked on the editor canvas** so you can describe changes while watching the flowchart and (in Developer view) the source update.

For **Visual** workflows, use Autopilot chat / “create with AI” flows to author and iterate; the canvas remains the place you drag and configure nodes.

## Flowchart and summary views

### Flowchart (Python workflows)

Python workflows render as a readable flowchart:

* Plain-English **step labels** (not only raw code identifiers)
* **Connected apps** called out on the flow
* **Collapsible** loop and branch cards for complex control flow
* **Overview** vs **Developer** detail: Overview emphasizes the business flow; Developer exposes the Python source alongside the graph

The same flowchart is used when inspecting a **past run**, with per-step status overlaid so you can see what executed, skipped, or failed.

### Summary (Visual and Python)

Both Visual and Python workflows support a **summary** view — an at-a-glance description of what the workflow does, with structured steps. Summaries are generated/updated in connection with publishing; if you change the workflow after publish, the summary may need a fresh publish to stay current.

Super Admins can configure **which model** writes workflow summaries and step notes (platform model settings).

## When to use which

| Goal                                                           | Prefer                                                  |
| -------------------------------------------------------------- | ------------------------------------------------------- |
| Assemble a process by dragging nodes and wiring conditions     | **Visual**                                              |
| Let Autopilot write substantial branching / data logic in code | **Python**                                              |
| Keep Autopilot docked next to a live flowchart while iterating | **Python**                                              |
| Follow existing V2 canvas docs and node catalog                | **Visual** → [Workflow Builder V2](/tools/workflows-v2) |
| “Build me a weekly report workflow” from chat                  | Autopilot **Build** mode (mode = platform default)      |

## Related

* [Workflows overview](/tools/workflows-overview) — V1 vs V2 product lines
* [Workflow Builder V2](/tools/workflows-v2) — Visual canvas how-to
* [Autopilot overview](/autopilot/autopilot-overview) — what Autopilot can build
* [Autopilot Modes](/autopilot/autopilot-modes) — Agent vs Build
* [EKB as MCP — Builder](/ekb-as-mcp/builder) — same build surface from Claude / Cursor
* [2.4.0 changelog](/changelogs/2.4.0) — release note for Visual and Python Workflow Builder