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 turns that into Argo Workflows YAML, shown beside the canvas as you work.

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

Expressions

Every function Argo accepts, and what it does

Start typing a condition and Dagweave offers the outputs, parameters and functions you can use there. Each function comes with its signature and an example that works.

Dagweave checks your conditions and loop expressions as you type, so a typo shows up in the editor, not halfway through a run.
Argo takes only part of Sprig. The list shows exactly that part.

Try it

Run a condition before the workflow does

Give the outputs a condition reads some sample values, and Dagweave works it out the way Argo will. You see the result and the exact line Argo gets.

A step name with a dash in it needs brackets in an expression. Dagweave tells you so before Argo does.

When a step fails

A step that only runs when another one fails

Page someone, clean up or roll back. Point a step at an earlier step's Failed result and it runs only then.

Wait for Succeeded, Failed, Errored or Skipped, or combine them.

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 WorkflowTemplate

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.

Add parameters to a WorkflowTemplate once, and every workflow that uses it can set them.
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.