File format

.workflow.md

An n8n-style automation graph, written as a Markdown file. Nodes, edges, credentials, and checkpoints — all plain text.

deploy.workflow.mdplain text · git-diffable
1## @automation deploy_on_release
2
3enabled: true
4concurrency: 1
5
6workflow:
7 trigger: release_hook
8 nodes:
9 - id: release_hook
10 type: trigger.webhook
11 parameters: { method: POST, path: /release }
12 - id: build
13 type: http.request
14 endpoint: DaemonExec
15 - id: notify
16 type: action.slack.post
17 credentials: SlackOAuth
18 connections:
19 - release_hook -> build
20 - build -> notify
canvas — parsed graphenabled

release_hook

Starts the workflow when an external service sends an HTTP request.

Inputs:

Method

POST

Path

/release
Completed · 1 result

Output:

body.Tagv1.0.22
body.Repositoryarg0_desktop
headers.X Github Eventrelease

build

Call an external API and use the response in the workflow.

Inputs:

Method

POST

URL

http://127.0.0.1:3999/exec

Body

{"cmd":"./scripts/release.sh v1.0.…
Completed · 1 result

Output:

Status200
json.ArtifactArg0-1.0.22-arm64.dmg
json.Signedtrue
127.0.0.1:3999

notify

Post a message to a Slack channel.

Inputs:

Channel

#releases

Message

Released tag — signed & notarized
Sending…

Output:

Slack: Post Message

@slack
release_hook → build → notify
01

Write nodes as Markdown

An @automation block: a trigger, a list of nodes, and connections between them.

02

Arg0 parses the graph

JSON items flow node to node — filters branch, loops batch, checkpoints pause for a human.

03

Render or run it

The same file drives the visual canvas and the executor — no second source of truth.

In practice

Ship a signed macOS build.

A real release, end to end — the flaky parts retry, the risky parts pause for you.

1

A tag fires it

Push v1.0.22 — your GitHub tag webhook hits trigger.webhook and starts the run. No clicking through a CI dashboard.

2

Flaky parts retry, not die

If the Electron CDN drops the download mid-build, the [on_error] edge routes to a cleanup/retry branch instead of a dead run.

3

Proof before install

codesign --verify, spctl, and stapler validate run as their own node — the build must be signed and notarized before anything moves.

4

You get the last word

checkpoint.manual pauses the graph. Approve from desktop or your phone — only then does it copy into /Applications and smoke-test.

release.workflow.md
1## @automation desktop_release
2
3enabled: true
4timeout: "45m"
5
6workflow:
7 trigger: tag_hook
8 nodes:
9 - id: tag_hook
10 type: trigger.webhook
11 parameters: { method: POST, path: /tags }
12 - id: build_sign
13 type: http.request
14 endpoint: DaemonExec # build + codesign + notarize
15 - id: verify
16 endpoint: DaemonExec # codesign --verify, spctl, stapler
17 - id: approve
18 type: checkpoint.manual
19 - id: install
20 endpoint: DaemonExec # /Applications + smoke test
21 - id: notify
22 type: action.slack.post
23 credentials: SlackOAuth
24 connections:
25 - tag_hook -> build_sign -> verify -> approve -> install -> notify
26 - build_sign -> cleanup [on_error]

Using it

Let your AI prove the flow works.

Add this endpoint as a custom connector in ChatGPT or Claude — the loop closes on your desktop.

1

Describe it

Your AI writes the .workflow.md.

2

Save it locally

Into an agent-exposed folder.

3

Validate

Parsed on your device.

4

Run — with your OK

Approval dialog, then real execution.

5

Iterate

Errors say exactly what failed.

ChatGPT
Claude
MCP

Runs ask on-screen first; .workflow.md can’t be written through the connector.

Node types

Built-in nodes, and each service’s own.

type: every node type reads the same way —

action
family — what kind
.
slack
service — which company
.
post
verb — what it does

Built-in — work on any item, no service needed

filter
Keep items that match conditions
switch
Route items to different branches
transform.*
Template, map, set, format fields
loop.*
forEach / splitInBatches over arrays
merge.*
Join branches back into one stream
delay.*
Wait a duration or until a timestamp
code.javascript
Run your own JS on the items
checkpoint.manual
Pause for human approval
http.request
Call any API via an @endpoint

Per service — family.service.verb

Gmail
action.gmail.listaction.gmail.sendaction.gmail.draftaction.gmail.mark_read
Google Sheets
action.sheets.appendaction.sheets.readaction.sheets.create
Slack
action.slack.postaction.slack.update
Notion
action.notion.create_pageaction.notion.query_dbaction.notion.update_page
Google Drive
action.drive.create_folderaction.drive.export_file
Any service — yours
http.request + @endpoint@integration → any API

Plain text, real graph

Every node is a YAML-like list item, every edge a `a -> b` line. Diffs, reviews, and merges work like any code file.

No secrets in the file

credentials: points at @auth / @integration names — real tokens resolve from the Vault at runtime, never from the .md.

Branching built in

Label edges for filter [true]/[false] and switch branches, loop with loop.forEach, and route failures with [on_error].