Skip to content
LiveGraph

Steer a running agent workflow

September 28, 2026

A run is heading to the wrong specialist. You can see which node is working and which edge it is about to take. In LiveGraph you drag that edge, and the next hop follows. The model call already in flight finishes and stays on the trail. Nothing is restarted.

That is possible because the engine never plans the whole run. It dispatches one hop, then reads the graph again and decides the next hop from what the graph looks like at that moment. A drag during a run you are watching is stored on that run. The saved graph, and therefore the next scheduled run, changes only if you keep the route.

Who this is for

A founder or a small agency that already runs agents against a real system — a repo, an inbox, a site — and is on the hook when a hop goes to the wrong place. Schedules and webhooks stay pinned: they snapshot the graph at the start, so an unattended job ignores a drag. Chat and the canvas Run button start live, which is the run a person is watching.

The platform price is flat. Solo is free. Team is one monthly price per workspace. Model spend is your keys at provider prices, or our hosted keys metered on top — either way, LiveGraph does not meter runs.

Try the drag

The live demo needs no account and no API key. A scripted model holds a hop open long enough to drag the edge and watch the next hop take the new target. When you want your own graphs, sign up and the included model runs them. Bring a key when you want a different provider.

If you are leaving a canvas that freezes when you press run — Flowise is unmaintained, and OpenAI Agent Builder shuts down on November 30, 2026 — start with the demo, then the Flowise importer or the Agent Builder migration guide.

See it running

The live demo needs no account and no API key — a scripted model drives the real engine while you reroute a run in flight. When you want your own graphs, sign up and the included model runs them; bring a key when you want a different provider.

Three products a loop shipped — citepath.ai, findefend.com, and modelright.dev, each from a paragraph-long brief.

Keep reading

  • Pause & Resume Workflow Automation with Human Approval Gates — LiveGraph Agent Orchestrator — LiveGraph is an agent orchestrator built for workflows that require mid-execution pauses and human decision points. Unlike static workflow builders, LiveGraph's live canvas allows approval gates to park runs mid-flight and resume them on decision — without restarting.
  • What counts as agent orchestration — a checklist the category keeps dodging — Two different tools claim 'orchestration': iPaaS pipelines that connect apps, and agent frameworks compiled into code. Neither lets you operate a run while it's running. Here's the checklist a real orchestrator has to satisfy — and where each camp lands.
  • Zapier and Make edit the next run. LiveGraph edits this one. — Zapier and Make build pipelines that change what the next run does; LiveGraph keeps the graph editable while a run is in flight. Connector catalogs vs a live orchestration canvas — an honest map of where each fits.
  • Why leaderless agent systems need live-editing — Peer agents routing to each other removes the supervisor node — not the need for steering. When nothing is in charge, the canvas is the only control surface left, and it has to be live.
  • Our engineering team is a LiveGraph graph. Here is what broke. — LiveGraph's own repo is improved by a LiveGraph loop: a tick fires the Lead, an engineer works through the GitHub MCP, CI routes its own verdict, and a human gate decides every merge. Including the three ways it failed.
  • Share a run people can watch, not a log they can't — POST /runs/:id/share mints a stateless token that renders a read-only, live-updating canvas — topology and hop status, never hop content. Embed it in docs, status pages, or a client deliverable.
  • LangGraph edits a run's state. LiveGraph edits a run's route. — LangGraph compiles your topology into code; LiveGraph keeps it in data you can mutate between hops. Two different primitives — an honest map of where each one fits.
  • Why you can't reroute a running n8n workflow (and why you can in LiveGraph) — Most engines compile a run before executing it, so mid-run edits only affect the next run. A per-hop engine makes rerouting free — here's the architecture.
  • Giving agents write access to real code without losing sleep — Worktree isolation, operator allowlists, encrypted secrets, and pushes only a human's literal keystrokes can trigger — the safety model, decision by decision.

LiveGraph

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

Product

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

Resources

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

Agents

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

Support

  • [email protected]

Legal

  • Privacy
  • Terms
© 2026 LiveGraphSite by Canweb Ltd.