Workflow visualizer

One constrained workflow graph, reused to author a draft, read a published definition, and watch a Run. Build mode edits the draft; run mode overlays Run and span state on the frozen snapshot.

1 min read Updated Aug 31, 2026

Workflow visualizer

A workflow must look the same when a person builds it, reads it, and watches it run.

The visualizer is one graph component over the workflow definition. Build mode edits draft_config. Run mode overlays execution state on the snapshot the Run froze. There is no second visualization model for runtime.

WORKFLOW VISUALISER - one picture of a workflow: while you build it, when you read it, and while it runs
WORKFLOW VISUALISER - one picture of a workflow: while you build it, when you read it, and while it runs
ONE PICTURE, AND THE THREE PLACES YOU MEET IT
ONE PICTURE, AND THE THREE PLACES YOU MEET IT
You open a workflow: the one you are writing, the one your team published, or one that is running right now
You open a workflow: the one you are writing, theone your team published, or one that is runningright now
It is drawn from the one saved workflow. The same boxes, in the same order, under the same names, wherever you opened it from.
It is drawn from the one saved workflow. Thesame boxes, in the same order, under the samenames, wherever you opened it from.
Click any box and its panel opens at the side. The picture carries the shape, and the panel carries the detail.
Click any box and its panel opens at the side. Thepicture carries the shape, and the panel carriesthe detail.
So you learn the workflow once. What you drew is what you read, and what you read is what you watch.
So you learn the workflow once. What you drew iswhat you read, and what you read is what youwatch.
WHILE YOU BUILD IT
add a box, join it to the next one, fill it in, take it out again
WHILE YOU BUILD ITadd a box, join it to the next one, fill it in, take it out again
WHEN YOU READ IT
the published workflow exactly as it stands. Nothing here changes by accident.
WHEN YOU READ ITthe published workflow exactly as it stands. Nothing herechanges by accident.
WHILE IT RUNS
the same boxes, each one now saying where it has got to
WHILE IT RUNSthe same boxes, each one now saying where it has got to
BUILDING ONE - and nothing can run it until you publish
BUILDING ONE - and nothing can run it until you publish
You say what you want in chat, or you place the boxes yourself. Both write the same one draft.
You say what you want in chat, or you place theboxes yourself. Both write the same one draft.
The only boxes you can place are the ones the platform can really run: run a tool, run an agent, run several at once, take one branch, wait, ask a person, call another workflow
The only boxes you can place are the ones theplatform can really run: run a tool, run an agent,run several at once, take one branch, wait, ask aperson, call another workflow
It checks the draft: everything it names really exists, every box that needs an input has one, and every branch says what happens otherwise
It checks the draft: everything it names reallyexists, every box that needs an input has one, andevery branch says what happens otherwise
You publish
You publish
A HALF-WRITTEN DRAFT IS SAFE
it is saved, and nothing can run it. Stop mid-sentence and come back tomorrow.
A HALF-WRITTEN DRAFT IS SAFEit is saved, and nothing can run it. Stop mid-sentence and comeback tomorrow.
IF SOMETHING IS MISSING
it names the box and what it needs, in plain words. It never publishes a workflow it cannot run.
IF SOMETHING IS MISSINGit names the box and what it needs, in plain words. It neverpublishes a workflow it cannot run.
THE PUBLISHED WORKFLOW
the one saved version the platform is allowed to run
THE PUBLISHED WORKFLOWthe one saved version the platform is allowed to run
WATCHING ONE RUN
WATCHING ONE RUN
It starts: you asked for it, something happened, or it was simply the time of day
It starts: you asked for it, something happened,or it was simply the time of day
The run takes its own copy of the workflow as it stood at that second, and keeps that copy for good
The run takes its own copy of the workflow as itstood at that second, and keeps that copy forgood
The same picture opens, and every box now says where it has got to. It keeps up while you watch it.
The same picture opens, and every box now sayswhere it has got to. It keeps up while you watch it.
Click a box to see what it did: how long it took, what it cost, what it produced, and the work inside it
Click a box to see what it did: how long it took,what it cost, what it produced, and the workinside it
THE WORKFLOW MOVED ON SINCE THIS RUN?
The run still shows its own copy, and the page says plainly that the workflow has changed since.
THE WORKFLOW MOVED ON SINCE THIS RUN?The run still shows its own copy, and the page says plainly that the workflow has changed since.
WATCHING IS NOT EDITING
You can stop a run, but you cannot rewire one while it is going. What you change belongs to the next run.
WATCHING IS NOT EDITINGYou can stop a run, but you cannot rewire one while it is going. What you change belongs to the next run.
WHAT A BOX SAYS WHILE THE RUN IS ON
WHAT A BOX SAYS WHILE THE RUN IS ON
not started yet
not started yet
running
24 of 40
running24 of 40
done
31 seconds
done31 seconds
waiting for you
to say yes
waiting for youto say yes
it failed
the search timed out
it failedthe search timed out
skipped
the other branch was taken
skippedthe other branch was taken
REAL SITUATIONS - four things people actually do with it
REAL SITUATIONS - four things people actually do with it
1 · YOU DREW IT THIS MORNING, AND IT RUNS TONIGHT
1 · YOU DREW IT THIS MORNING, AND IT RUNS TONIGHT
You place seven boxes, join them up, and publish
You place seven boxes, join them up, and publish
The same picture is now what your team reads on the workflow page, and nobody has to be told how it works
The same picture is now what your team reads on the workflowpage, and nobody has to be told how it works
Tonight it runs, and the same picture shows it running. Nothing was drawn twice.
Tonight it runs, and the same picture shows it running. Nothingwas drawn twice.
2 · IT IS WAITING ON YOU, AND YOU CAN SEE WHERE
2 · IT IS WAITING ON YOU, AND YOU CAN SEE WHERE
A run reaches the box that asks a person before it sends anything
A run reaches the box that asks a person before it sends anything
That box says it is waiting, and everything after it is still greyed out. Open it and you see exactly what will happen.
That box says it is waiting, and everything after it is still greyedout. Open it and you see exactly what will happen.
You approve it there, and the picture carries on by itself the moment the run resumes.
You approve it there, and the picture carries on by itself themoment the run resumes.
3 · SOMETHING FAILED IN THE MIDDLE
3 · SOMETHING FAILED IN THE MIDDLE
The enrichment box turns red and says the search timed out
The enrichment box turns red and says the search timed out
One click shows what that box did, and one more shows the single call that failed
One click shows what that box did, and one more shows thesingle call that failed
You find it in seconds, and the rest of the picture stays readable while you do.
You find it in seconds, and the rest of the picture stays readablewhile you do.
4 · SOMEONE CHANGED THE WORKFLOW AFTER THE RUN
4 · SOMEONE CHANGED THE WORKFLOW AFTER THE RUN
A colleague edits and republishes the workflow this afternoon
A colleague edits and republishes the workflow this afternoon
Last week's run still shows the workflow as it was that day, and says the current one differs
Last week's run still shows the workflow as it was that day, andsays the current one differs
The record of what actually ran is never quietly rewritten by a later edit.
The record of what actually ran is never quietly rewritten by alater edit.
WHAT THE COLOURS MEAN
WHAT THE COLOURS MEAN
you start it
you start it
an ordinary step
an ordinary step
your decision
your decision
happens on its own
happens on its own
what the platform keeps
what the platform keeps
what you get back
what you get back
waiting on a person
waiting on a person
it does not happen
it does not happen
One picture, drawn from one saved workflow. The builder, the workflow page and the run page are three doors onto it - not three pictures that can disagree with each other.
One picture, drawn from one saved workflow. The builder, the workflow page and the run page are three doors onto it - not three pictures that can disagree with each other.
The picture only shows the workflow. It never runs anything itself, and it can only place boxes the platform already knows how to run, so nothing can be drawn that cannot be run.
The picture only shows the workflow. It never runs anything itself, and it can only place boxes the platform already knows how to run, so nothing can be drawn that cannot be run.
A run keeps its own copy of the workflow. So an old run always shows what really happened, however many times the workflow has been changed since.
A run keeps its own copy of the workflow. So an old run always shows what really happened, however many times the workflow has been changed since.Text is not SVG - cannot display
WORKFLOW VISUALISER - one picture of a workflow: while you build it, when you read it, and while it runs
WORKFLOW VISUALISER - one picture of a workflow: while you build it, when you read it, and while it runs
ONE PICTURE, AND THE THREE PLACES YOU MEET IT
ONE PICTURE, AND THE THREE PLACES YOU MEET IT
You open a workflow: the one you are writing, the one your team published, or one that is running right now
You open a workflow: the one you are writing, theone your team published, or one that is runningright now
It is drawn from the one saved workflow. The same boxes, in the same order, under the same names, wherever you opened it from.
It is drawn from the one saved workflow. Thesame boxes, in the same order, under the samenames, wherever you opened it from.
Click any box and its panel opens at the side. The picture carries the shape, and the panel carries the detail.
Click any box and its panel opens at the side. Thepicture carries the shape, and the panel carriesthe detail.
So you learn the workflow once. What you drew is what you read, and what you read is what you watch.
So you learn the workflow once. What you drew iswhat you read, and what you read is what youwatch.
WHILE YOU BUILD IT
add a box, join it to the next one, fill it in, take it out again
WHILE YOU BUILD ITadd a box, join it to the next one, fill it in, take it out again
WHEN YOU READ IT
the published workflow exactly as it stands. Nothing here changes by accident.
WHEN YOU READ ITthe published workflow exactly as it stands. Nothing herechanges by accident.
WHILE IT RUNS
the same boxes, each one now saying where it has got to
WHILE IT RUNSthe same boxes, each one now saying where it has got to
BUILDING ONE - and nothing can run it until you publish
BUILDING ONE - and nothing can run it until you publish
You say what you want in chat, or you place the boxes yourself. Both write the same one draft.
You say what you want in chat, or you place theboxes yourself. Both write the same one draft.
The only boxes you can place are the ones the platform can really run: run a tool, run an agent, run several at once, take one branch, wait, ask a person, call another workflow
The only boxes you can place are the ones theplatform can really run: run a tool, run an agent,run several at once, take one branch, wait, ask aperson, call another workflow
It checks the draft: everything it names really exists, every box that needs an input has one, and every branch says what happens otherwise
It checks the draft: everything it names reallyexists, every box that needs an input has one, andevery branch says what happens otherwise
You publish
You publish
A HALF-WRITTEN DRAFT IS SAFE
it is saved, and nothing can run it. Stop mid-sentence and come back tomorrow.
A HALF-WRITTEN DRAFT IS SAFEit is saved, and nothing can run it. Stop mid-sentence and comeback tomorrow.
IF SOMETHING IS MISSING
it names the box and what it needs, in plain words. It never publishes a workflow it cannot run.
IF SOMETHING IS MISSINGit names the box and what it needs, in plain words. It neverpublishes a workflow it cannot run.
THE PUBLISHED WORKFLOW
the one saved version the platform is allowed to run
THE PUBLISHED WORKFLOWthe one saved version the platform is allowed to run
WATCHING ONE RUN
WATCHING ONE RUN
It starts: you asked for it, something happened, or it was simply the time of day
It starts: you asked for it, something happened,or it was simply the time of day
The run takes its own copy of the workflow as it stood at that second, and keeps that copy for good
The run takes its own copy of the workflow as itstood at that second, and keeps that copy forgood
The same picture opens, and every box now says where it has got to. It keeps up while you watch it.
The same picture opens, and every box now sayswhere it has got to. It keeps up while you watch it.
Click a box to see what it did: how long it took, what it cost, what it produced, and the work inside it
Click a box to see what it did: how long it took,what it cost, what it produced, and the workinside it
THE WORKFLOW MOVED ON SINCE THIS RUN?
The run still shows its own copy, and the page says plainly that the workflow has changed since.
THE WORKFLOW MOVED ON SINCE THIS RUN?The run still shows its own copy, and the page says plainly that the workflow has changed since.
WATCHING IS NOT EDITING
You can stop a run, but you cannot rewire one while it is going. What you change belongs to the next run.
WATCHING IS NOT EDITINGYou can stop a run, but you cannot rewire one while it is going. What you change belongs to the next run.
WHAT A BOX SAYS WHILE THE RUN IS ON
WHAT A BOX SAYS WHILE THE RUN IS ON
not started yet
not started yet
running
24 of 40
running24 of 40
done
31 seconds
done31 seconds
waiting for you
to say yes
waiting for youto say yes
it failed
the search timed out
it failedthe search timed out
skipped
the other branch was taken
skippedthe other branch was taken
REAL SITUATIONS - four things people actually do with it
REAL SITUATIONS - four things people actually do with it
1 · YOU DREW IT THIS MORNING, AND IT RUNS TONIGHT
1 · YOU DREW IT THIS MORNING, AND IT RUNS TONIGHT
You place seven boxes, join them up, and publish
You place seven boxes, join them up, and publish
The same picture is now what your team reads on the workflow page, and nobody has to be told how it works
The same picture is now what your team reads on the workflowpage, and nobody has to be told how it works
Tonight it runs, and the same picture shows it running. Nothing was drawn twice.
Tonight it runs, and the same picture shows it running. Nothingwas drawn twice.
2 · IT IS WAITING ON YOU, AND YOU CAN SEE WHERE
2 · IT IS WAITING ON YOU, AND YOU CAN SEE WHERE
A run reaches the box that asks a person before it sends anything
A run reaches the box that asks a person before it sends anything
That box says it is waiting, and everything after it is still greyed out. Open it and you see exactly what will happen.
That box says it is waiting, and everything after it is still greyedout. Open it and you see exactly what will happen.
You approve it there, and the picture carries on by itself the moment the run resumes.
You approve it there, and the picture carries on by itself themoment the run resumes.
3 · SOMETHING FAILED IN THE MIDDLE
3 · SOMETHING FAILED IN THE MIDDLE
The enrichment box turns red and says the search timed out
The enrichment box turns red and says the search timed out
One click shows what that box did, and one more shows the single call that failed
One click shows what that box did, and one more shows thesingle call that failed
You find it in seconds, and the rest of the picture stays readable while you do.
You find it in seconds, and the rest of the picture stays readablewhile you do.
4 · SOMEONE CHANGED THE WORKFLOW AFTER THE RUN
4 · SOMEONE CHANGED THE WORKFLOW AFTER THE RUN
A colleague edits and republishes the workflow this afternoon
A colleague edits and republishes the workflow this afternoon
Last week's run still shows the workflow as it was that day, and says the current one differs
Last week's run still shows the workflow as it was that day, andsays the current one differs
The record of what actually ran is never quietly rewritten by a later edit.
The record of what actually ran is never quietly rewritten by alater edit.
WHAT THE COLOURS MEAN
WHAT THE COLOURS MEAN
you start it
you start it
an ordinary step
an ordinary step
your decision
your decision
happens on its own
happens on its own
what the platform keeps
what the platform keeps
what you get back
what you get back
waiting on a person
waiting on a person
it does not happen
it does not happen
One picture, drawn from one saved workflow. The builder, the workflow page and the run page are three doors onto it - not three pictures that can disagree with each other.
One picture, drawn from one saved workflow. The builder, the workflow page and the run page are three doors onto it - not three pictures that can disagree with each other.
The picture only shows the workflow. It never runs anything itself, and it can only place boxes the platform already knows how to run, so nothing can be drawn that cannot be run.
The picture only shows the workflow. It never runs anything itself, and it can only place boxes the platform already knows how to run, so nothing can be drawn that cannot be run.
A run keeps its own copy of the workflow. So an old run always shows what really happened, however many times the workflow has been changed since.
A run keeps its own copy of the workflow. So an old run always shows what really happened, however many times the workflow has been changed since.Text is not SVG - cannot display
One picture of a workflow, and the three places a person meets it. The middle band is authoring: only the boxes the runtime can execute may be placed, and a draft cannot run until it is published. The third band is a Run, which keeps its own frozen copy of the workflow, so an old Run always shows what really ran. The strip below it is the whole vocabulary a box can carry while the Run is on.

Product goal

One mental model for a workflow:

TEXT
Workflow definition
        │
        ▼
   Workflow graph
        │
   ┌────┼───────────┐
   ▼    ▼           ▼
 build  view        run
 draft  published   live / historical

A node means the same thing in all three places. A Company Research Agent node is editable in the builder, read-only on the definition page, and status-bearing in a Run.

Why this fits the platform

The platform already holds every record the graph needs. A workflow is a definition, and a definition is data with a small deterministic vocabulary. A Run freezes an immutable snapshot of published_config at start. Execution produces child Runs and spans. The visualizer combines those records and adds none.

TEXT
build mode
draft_config ──> WorkflowGraph ──> DefinitionService ──> validate ──> publish

run mode
Run snapshot + Run + child Runs + spans ──> WorkflowGraph

No execution logic belongs in the visualizer. Inngest stays the durable orchestrator, the worker executes the workflow, and the UI renders product state only. See runtime definitions and runtime execution.

The node vocabulary is the runtime's, unchanged

The visual builder places the eight node types the runtime executes, and nothing else. Two of them are containers. The runtime owns this table; the visualizer renders it.

NodeKindWhat the graph draws
sequencecontainerThe ordered relationship between children
parallelcontainerA fixed set of children that run at the same time
toolstepOne deterministic tool call
agentstepOne agent as a child Run
subworkflowstepOne published workflow as a child Run
branchstepOne child chosen by the shared ConditionEvaluator, with a declared default
waitstepA hold for an event or a delay
approvalstepA hold for a person

wait and approval are two nodes, not one. A wait resumes on an event or a timer. An approval resolves an approval row, and the human review inbox is the global queue for it.

This is not an unrestricted DAG canvas. No code nodes, no loops, no dynamic graph rewriting at run time, no user-defined node types, and no dynamic fan-out node. Fan-out stays inside one tool step or one agent step, which reports one result, so the shape stays checkable at publish time.

Three modes, one component

TEXT
<WorkflowGraph
  definition={definition}
  mode="edit | view | run"
  execution={optionalExecutionOverlay}
/>
SurfaceModeBehavior
Agent BuildereditAdd, connect, configure, remove and validate nodes on the draft
Definition detailviewRead-only picture of published_config
Run ExplorerrunRead-only Run snapshot, with live or historical execution overlaid

Layout and node identity stay stable between modes, so a person never relearns the workflow.

Build mode

Build mode is a visual editor for the draft. It is not a workflow engine.

TEXT
┌─────────────────┐
│ Find Companies  │ agent
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Enrich Company  │ agent
└────────┬────────┘
         │
         ▼
    ┌──────────┐
    │ Score ≥80│ branch
    └────┬─────┘
       /   \
     yes    default
      │      │
      ▼      ▼
┌──────────┐ Finish
│ Review   │ approval
└────┬─────┘
     │
     ▼
┌─────────────────┐
│ Email Sequence  │ subworkflow
└─────────────────┘

Node configuration

Selecting a node opens a side panel. Configuration never sits on the canvas.

TEXT
Enrich Company

Type      agent
Agent     Company Research Agent
Input     company = find_companies.company
Output    company_intelligence

The editor writes draft_config through PATCH /api/v1/agentic/definitions/{id}/draft, and sends expected_updated_at on every write. Two people editing one draft is normal, so a stale write is refused rather than merged. The editor never writes execution records and never bypasses validation.

Validation

The builder may give immediate client-side guidance. Publishability is decided by the deterministic definition validator, and by nothing in the frontend.

The validator holds:

  • node ids are unique;
  • every referenced agent, tool, skill and workflow exists and is visible to the organization;
  • required inputs are connected, and every input and output reference resolves;
  • a branch declares a default;
  • branch conditions use the supported deterministic operators;
  • subworkflow nesting stays inside the platform cap;
  • the scopes the referenced capabilities need are grantable.

A workflow written in chat and a workflow drawn by hand run the same validator, because both are one draft_config.

Conversational authoring and visual editing are two doors

The visualizer does not replace the front door builder chat. Both edit one draft.

TEXT
"research prospects, wait for approval, then start outreach"
                    │
              Front Door
                    │
        Definition Builder Agent
                    │
               draft_config
                    │
          Workflow visualizer
                    │
          person reviews / edits
                    │
            validate ──> publish
  1. Conversation first — describe the workflow, and let the builder agent write the draft.
  2. Visual first — compose or change the same draft in the graph.

A change in either surface updates the same durable draft. Until a publish, nothing can run it.

Run mode

Run mode renders the immutable snapshot the Run froze at start. It does not render the current published definition.

TEXT
current published_config ────┐
                             │ they differ after an edit
Run snapshot ────────────────┘
          │
          ▼
     run visualizer

The page states plainly when the current definition differs from the snapshot, and links to the current definition. A historical Run must render correctly without reading the current definition at all.

Runtime overlays

Each node carries one small overlay.

StateExample rendering
Pending○ Find People
Running● Find People · 24/40
Succeeded✓ Find People · 31s
Waiting⚠ Human Review · waiting
Failed✕ Enrichment · Exa timed out
Skipped– Email Sequence · branch not taken
Cancelled× Research · cancelled

Live state comes from the Run stream. Historical state is rebuilt from the Run row and its spans, with no event log. The UI never reads Inngest execution state.

Node details

Selecting a node opens its execution detail.

TEXT
Company Research Agent

Status       succeeded
Duration     28.2s
Cost         $0.14
Child Run    run_abc123

Input        Acme Ltd
Output       Research completed

Execution
├─ LLM                    3.2s
├─ web_search             8.1s
├─ scrape_page            6.4s
└─ LLM                    2.8s

A node is therefore the friendly entry point into the Run and span tree. It does not replace it.

Progress is a whole Run, not a graph feed

The graph answers where the Run is, and how it got there. It is not the only way to read output. The Run Explorer keeps its four product views.

ViewQuestion
OverviewWhat is happening?
ExecutionWhat did the workflow and its agents do?
ResultsWhat business output did it produce or change?
DefinitionWhat exact configuration ran?

The graph is reused in Overview and Definition, and navigates into Execution. Result tables and created CRM records stay separate.

Approvals in place

An approval node shows the decision where it interrupted the Run.

TEXT
✓ Qualify Prospects
        │
        ▼
⚠ Human Review
  waiting for approval
        │
        ▼
○ Email Sequence

Selecting it shows the proposed action, the rule that asked for a person, who requested it, the exact target or content, the expiry, and the action that resolves it. The approval inbox stays the global queue. The visualizer renders the same approval row, and never a second one.

Parallel work and subworkflows

A parallel container stays readable without becoming a free-form canvas.

TEXT
          ┌─ Find People ───────┐
Enrich ───┤                     ├── Merge
          └─ Find Signals ──────┘

Each branch updates on its own. The merge advances only when the runtime reports the container complete.

A subworkflow draws as one collapsed node.

TEXT
┌─────────────────────┐
│ Email Sequence      │
│ subworkflow     ›   │
└─────────────────────┘

A person drills into the child Run instead of expanding the nested graph inline. Nesting is capped at publish time, and the parent graph stays readable.

UX rules

  • Definition first. Node identity and labels come from the definition. Runtime only adds an overlay.
  • Stable identity. A node keeps one id across build, view and run.
  • Configuration off-canvas. The graph carries shape. The panel carries detail.
  • Progressive disclosure. Show business status first. Tool, LLM and span detail is one click deeper.
  • No infrastructure vocabulary. Never show an Inngest function id, an attempt count or a worker detail in the product UI.
  • No silent definition drift. A historical Run always renders its own snapshot.
  • Mobile degrades vertically. The same definition stays understandable without a wide canvas.
  • The visualizer never changes a Run in flight. Editing edits a draft for future Runs. Cancel stays a Run control, and disable stops a new Run tree only.

Contracts it consumes

The visualizer needs no new execution API. It reads the definition and Run contracts the platform already owns. See surfaces.

Build mode

TEXT
GET    /api/v1/agentic/definitions/{id}
PATCH  /api/v1/agentic/definitions/{id}/draft       expected_updated_at
POST   /api/v1/agentic/definitions/{id}/validate
POST   /api/v1/agentic/definitions/{id}/publish     expected_updated_at
POST   /api/v1/agentic/definitions/{id}/fork

Run mode

TEXT
GET    /api/v1/agentic/runs/{id}
GET    /api/v1/agentic/runs/{id}/spans?cursor=
GET    /api/v1/agentic/runs?parent_run_id={id}&cursor=
GET    /api/v1/agentic/runs/{id}/stream

There is no run tree route, and the visualizer must not ask for one. Run detail embeds no child list and carries child_count only, because a parallel node's widest case is five hundred children. The graph reads children through the paged list route, one node at a time, as it needs them.

The minimum the graph needs

TEXT
definition (or Run snapshot)
  nodes[]
    id
    type
    label
    config
    input bindings
  the deterministic parent/child relationships

RunExecutionOverlay
  run_id
  node_id ->
    status
    started_at
    ended_at
    progress
    child_run_id?
    error_summary?
    result_summary?

The overlay is a projection of the Run and its spans. Do not persist a second graph for visualization, and do not add a durable event table beside the spans. Layout metadata may live with the definition if manual positioning earns its place later. Execution state stays in Runs and spans.

V1 scope

  1. A vertical, top-to-bottom graph.
  2. All eight node types, with sequence and parallel drawn as containers.
  3. Click a node, open the side panel.
  4. Add, connect, configure and remove nodes in build mode.
  5. Deterministic validation and an explicit publish.
  6. A read-only mode over published_config.
  7. Live status overlays on a running Run.
  8. A completed Run rebuilt from the Run row and its spans.
  9. Approval state shown in place.
  10. A drill from an agent or subworkflow node into the child Run.

Not in V1

  • Free-form DAG authoring, code nodes, loops, or a dynamic fan-out node.
  • Graph mutation at run time.
  • A custom node or plugin SDK.
  • Visual editing of a Run in flight.
  • Inngest-level visualization.
  • A second event store, or a second graph representation for runtime.
  • Minimaps, canvas collaboration, comments and multiplayer editing.
  • Automatic migration of a customized workflow when a platform template changes.
  • Definition revision, history and rollback. The platform contract already excludes it.

Product situations

#SituationWhat happens
1The builder agent writes the first draftA person asks for a prospect qualification workflow in chat. The UI opens that same draft in the graph. The person swaps the qualification agent, adds an approval node, validates and publishes.
2A person builds it by handAn admin starts from a blank workflow or forks a platform template, places nodes from the constrained set, connects inputs, validates and publishes. The result is the same definition shape a conversation produces.
3A person watches a live RunThe Run starts from chat or a trigger. The Run Explorer opens the graph from the snapshot. Nodes move pending -> running -> succeeded, and counters update on the stream.
4A Run waits for a personThe approval node reads waiting, and later nodes stay pending. The person approves it in the node, and the same graph resumes when the runtime resumes the Run.
5The definition changed after the RunA person republished the workflow. An older Run still renders its own snapshot. The page says the current definition differs, and links to it.
6The Run is older than the span windowSpans are kept 90 days and Runs 13 months, so a Run in between renders partly blank: an agent or subworkflow node still has a child Run and keeps its status, while a tool, wait, branch or approval node loses the span it read and has none. Say so on the graph. Left unlabelled it reads as a workflow whose steps never ran, which is the one thing it does not mean.
6A failure is investigatedThe enrichment node fails. The graph shows the failed node and a short error. Clicking it opens the execution detail, then the tool span that holds the failed web_search call.

Success criteria

  • A non-technical person can say where a Run is without opening a log.
  • A workflow authored in chat and one authored visually produce the same definition shape.
  • The UI renders a historical Run without reading the current definition.
  • No visualizer-specific runtime, event store or second graph is introduced.
  • Every drawn node maps to definition data, and, while running, to Run and span data.
  • One graph component serves the builder, the definition page and the Run Explorer.

Key decision

This replaces the V1 rule "no visual DAG builder" with a narrower one:

Build a constrained visual editor and runtime visualizer over the same definition graph. Do not build a general-purpose DAG platform.

The exclusion that stays is arbitrary workflow code, loops and dynamic fan-out. The runtime vocabulary does not grow. What grows is how a person sees it.

workflows
visualizer
builder
definitions
runs
spans
graph
approvals