Skip to content
LiveGraph

Move your CrewAI crews to LiveGraph

CrewAI runs inside a Python process — you read the log when it's over. LiveGraph puts the same crew on a canvas that stays live while it runs.

How the move works

This one is a translation, not an import — there's no file importer for CrewAI, and your crew isn't a file anyway. The path:

  • Grab your crew definition — the crew.jsonc/agent configs, or the Python where agents, tasks, and the process are declared.
  • Paste it into the describe box when you create a graph — roles, goals, and task descriptions are exactly what a generated graph needs.
  • Review the generated graph. Agents become nodes, task order becomes edges, and it lands as an ordinary editable graph on the live canvas.

What a crew maps to

CrewAILiveGraph
Agent (role, goal, backstory)Worker node — role and goal become the node's role and prompt; model picked per node, any provider
Task (description, expected_output)The node's job and handoff contract — what it does and what the next node receives
Process.sequentialexplicit edges — the fixed chain, visible on the canvas
Process.hierarchical + managerA router/dispatcher node — auto edges where it picks the next specialist
Flow @listen / @router stepsEdges and router nodes — the same fan-out, drawn where you can see it
Human-in-the-loop flagsApproval gates — the run parks at /approvals with the pending payload visible
Custom tools (Python functions)Rewired per node as MCP servers with an exact-name allowlist, http_request, or file access

What carries over

  • Roles and goals. An agent's role/goal/backstory is a prompt — it moves verbatim into the node.
  • Task structure. What each task does, what output it owes, and which agent owns it — that's the graph's shape.
  • Process intent. Sequential chains, hierarchical delegation, and flow routers all have direct equivalents as edges and routers.

What doesn't move

  • Your Python. Custom tool functions, task callbacks, and guardrail code don't execute on the canvas — each becomes a tool the node calls (MCP or HTTP to code you own). This is the real porting work; be honest with yourself about how much logic lives there.
  • LLM connections and env keys. Provider credentials get re-entered here — encrypted at rest, scoped per node, or run on our hosted keys.
  • Memory and knowledge config. CrewAI's entity/short/long-term memory settings have no direct equivalent — persistent context becomes shared graph context or a memory node, designed rather than carried over.
  • One-way, deliberately. Crew Studio's code export is one-way; so is this. After the move the graph is the source of truth — there's no path back to generated Python.

Why move

A crew running in a process is a black box until it finishes — you get verbose logs after the fact and a re-run if a hop went wrong. On LiveGraph the run executes on the canvas: 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 instead of restarting it. Prompt edits don't need a deploy, and the person on call doesn't need the repo.

Start

Create an account, paste your simplest crew's config 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.

Sign up freeAlready have an account? Log in

LiveGraph

Model-agnostic agent orchestration on a live canvas. Hosted at livegraph.ai.

Product

  • Live demo
  • Pricing
  • Security
  • Automations
  • Compare
  • Migrate from Flowise
  • Migrate from Agent Builder
  • Sign up

Resources

  • Blog
  • Docs
  • Changelog
  • Model Radar
  • Status
  • RSS

Agents

  • Agent guide
  • llms.txt
  • llms-full.txt
  • MCP integration

Support

  • [email protected]

Legal

  • Privacy
  • Terms
© 2026 LiveGraphSite by Canweb Ltd.