Visual editor

Build Argo Workflows on a canvas.

dagweave draws the workflow on a canvas before you run it, with the YAML it compiles to sitting right beside it.

The problem

Only the YAML expert can touch it.

Retry strategies, artifact repository config, node selectors: one engineer on the team knows how to set them.

A workflow is a graph. YAML hides the parallel steps and the failure paths.

The canvas

The manifest updates while you edit

You place steps and draw the dependencies between them. dagweave compiles that straight into Argo Workflows YAML, in a pane beside the canvas. That pane is the whole workflow in one file, which is the form a dispatch sends; publishing splits it into a file per reusable template by default.

kubectl and argo submit read it like a hand-written manifest.
Covers containers, scripts, Kubernetes resources and executor plugins.
A validity check runs before dispatch. A broken graph gets caught in the editor, not the workflow controller.

compiled output: Workflow, WorkflowTemplate or CronWorkflowyaml

apiVersion: argoproj.io/v1alpha1
kind: CronWorkflow
metadata:
  name: nightly-etl
spec:
  schedule: "0 2 * * *"
  workflowSpec:
    entrypoint: main

The inspector

A form for every field

Retries, timeouts, node selectors, env, pod labels, active deadlines: the fields nobody wants to hand-edit. dagweave puts each one in a form, built straight from the step's own schema.

edited in the form, not the fileyaml

retryStrategy:
  limit: "3"
  retryPolicy: OnTransientError
activeDeadlineSeconds: 900
nodeSelector:
  workload: batch

Depth

Workflows nest, and so does the canvas

Real workflows nest: a DAG that calls a template that's itself a DAG, three levels down. Each one opens as its own canvas, with a trail back to where you came from.

Set a child step's condition on the canvas, as a form field rather than a template expression.
One step's outputs feed the next step's inputs.

nested templatesyaml

templates:
  - name: main
    dag:
      tasks:
        - { name: build, template: build }
        - { name: deploy, template: deploy, depends: build }
  - name: deploy

Reuse

Two identical steps become one template

dagweave compiles each step to a WorkflowTemplate in your own registry. Build the same container step in five workflows, and the registry holds one copy, versioned, referenced five times.

Parameterize a template once; it covers every call site.
Workflows already published stay on the version they name.

define once, reference everywhereyaml

# one WorkflowTemplate, minted from the step body
templates:
  - name: run-tests
    inputs:
      parameters: [{ name: suite }]

Draw it before you run it.

dagweave is in early access. Leave an email and we will bring you on as we open it up.