Dify's workflow canvas is good at building — the difference here is what the canvas does while a run is executing.
How the move works
There's no Dify file importer, and we'd rather say that than half-convert your app. The honest path is generate, not import:
Export the DSL. In Dify Studio, open the app and choose Export DSL — you get a YAML file with the orchestration, node settings, and prompt templates.
Paste it into the describe box when you create a graph here, or describe the app in words. LiveGraph generates the equivalent node/edge structure.
Review the generated graph on the canvas. It's an ordinary editable graph — tighten prompts, rewire edges, then run it live.
What an app maps to
Dify
LiveGraph
User Input / Trigger start nodes
Runs start from chat, the canvas, schedules, or webhooks
LLM nodes
Worker nodes — role, prompt, and model per node; any provider, not one vendor
IF/ELSE and branching
explicit edges, or auto edges where a router picks the next specialist
Knowledge Retrieval nodes
No built-in equivalent — wire retrieval in through an MCP server or http_request endpoint scoped to that node
Code / HTTP Request nodes
Per-node http_request, file access, or MCP servers with an exact-name tool allowlist
Chatflow conversation layer + Answer nodes
Runs return their output to where they started — chat, canvas, webhook — but LiveGraph doesn't host an end-user app surface
What carries over
Orchestration. The node order and branching — the DSL spells it out, so the generated graph follows it faithfully.
Prompts and model parameters. Every prompt template in the export moves into node prompts verbatim; each node picks its own provider afterward.
Trigger intent. Schedule and webhook starts map to the same firing model here.
What doesn't move
Credentials and model provider setup. Dify's provider configuration and tool authorizations stay in Dify — each node's tools and keys are re-entered here, scoped per node.
Knowledge bases. The DSL exports connections, not data — and LiveGraph has no built-in dataset/retrieval store. Retrieval becomes a tool call to infrastructure you control.
Conversation variables. Chatflow's per-conversation state has no direct equivalent — persistent context becomes shared graph context or a memory node, designed deliberately rather than carried over.
The published app. Dify can expose an app as a hosted webapp, API, or MCP server. LiveGraph orchestrates agents against your systems; runs start from chat, the canvas, schedules, or webhooks — there's no hosted end-user surface to repoint.
Plugin marketplace tools. Marketplace plugins become MCP servers or HTTP endpoints you wire per node.
Why move
In Dify a run plays back as a log — the canvas designed the workflow, but once it's executing you're watching history. On LiveGraph the canvas stays live: you watch each hop as it happens, a run parks at an approval gate until a person says yes, and dragging an edge mid-run steers the run you're watching. If your Dify apps are really multi-agent systems dressed as workflows, this is the surface they were missing.
Start
Create an account, paste your simplest app's DSL into the describe box, and run it once — or watch the live demo first: a real multi-agent graph running in your browser, no signup.