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. Everyone else does the job by hand instead.

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. What you read there is the file you publish.

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 CronWorkflow yaml

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.

A coverage meter on each step shows when nothing is left to hand-edit.

edited in the form, not the file yaml

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

Depth

Double-click to go a level deeper

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 and its failure policy on the canvas.
Map one step's outputs into the next step's inputs by drawing the connection.

nested templates yaml

templates:
  - name: main
    dag:
      tasks:
        - { name: build, template: build }
        - { name: deploy, template: deploy, depends: build }
  - name: deploy   # double-click 'deploy' to drill in

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 everywhere yaml

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

Import what you already run From a GitHub repo, from a live cluster, or pasted straight in. Catalog and marketplace Building blocks that land on the canvas already parameterized. Your YAML, your repo A commit or a pull request against a GitHub repo you choose.