Authoring over MCP

Let an assistant write it. We check its work.

Point your assistant at dagweave over MCP and ask for a workflow. What comes back has been through the quality gates every workflow here passes, and what you review is a graph rather than ninety lines of YAML.

The problem

An LLM will write you Argo YAML. It won't tell you where it guessed.

A task that depends on a step whose name is spelled almost right. A template reference that resolves to nothing. A field the schema has never had. All of it looks right.

You find out at admission, or four minutes into a run on a real cluster, or in review when somebody happens to spot it.

The check

A draft goes through the gates your own workflows go through

A manifest a model invented four seconds ago gets the same parse, the same validation and the same compile as one somebody drew on the canvas. It happens before the thing is saved, and long before a cluster hears about it.

Template references that resolve to nothing, and DAG edges naming tasks that are not there.
Fields the Argo Workflows schema has never had, wherever the model picked them up.
A step compiled without a container image, which your cluster would take and then fail on with nothing useful to say.
One path, not two. There is no lenient mode for a machine.

what comes backtext

error    tasks[2].template   no template named "load-warehouse"
error    tasks[2].depends    "transfrom" is not a task in this DAG
error    tasks[2].retries    not a field on a DAG task
warning  parameters[1]       "region" is declared and never used

The correction

It gets told what's wrong, in terms it can act on

Handing a model the schema and hoping does not work. A short list of faults, each with the path it sits at, does. It fixes those lines and asks again.

Checking a draft stores nothing. It can check as often as it likes.
The compiled result comes back with the faults, so it can see what its draft actually becomes.
Saving is a separate ask, under a scope you granted on purpose.

second time roundtext

valid   true
kind    CronWorkflow
graph   extract -> transform -> load
retry   load: 3 attempts, OnTransientError

The review

Read a graph, not a manifest you didn't write

The workflow opens on the same canvas as everything else. The shape is what you wanted to check, and the canvas is where the shape is.

What lands in your repo is ordinary Argo Workflows YAML. Nothing in it says a model wrote it.
It runs when you dispatch it, and not a moment before.

the corrected workflowyaml

dag:
  tasks:
    - name: extract
      template: extract-orders
    - name: transform
      template: transform-orders
      depends: extract
    - name: load
      template: load-orders
      depends: transform

Blast radius

It reaches exactly as far as the person holding the token

Writing is its own scope. A read token stays a read token.

A model sees the workflows its token's owner sees, and no others.
Checking a draft asks for the same read scope as listing them, and stores nothing.
Starting a run has always been its own scope, and the run is written down whoever asked for it.
What an assistant changed goes in the audit log, refusals included. What it read is counted against its token instead.

the MCP tools an assistant getstext

check a draft     workflows:read     nothing is stored
list workflows    workflows:read     what your token can already see
save a workflow   workflows:write    granted on purpose, audited
start a run       runs:write         audited, and its own scope

Let it draft. You still decide.

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