Workflows

A workflow automates batch production. You draw it once as nodes and wires — where the files come from, what jobs they become, and the order those jobs run in — and run it again for every shift, batch or order. Workflows are optional: they're worth it when you engrave many files, pull work from a database, or run several machines in a set sequence.

You don't have to draw it yourself: the editor's assistant builds a workflow from a description in your own words, on the canvas while you watch. This page covers the editor and the assistant, the node types, a first workflow, designs and formulas, values asked when running, databases, machine commands, compiling, and how runs are tracked.

The Workflows page

Workflows (under Automation in the sidebar) lists your workflows as cards, twelve to a page and newest first; the search box beside New workflow finds one by any part of its name. Each card offers:

• Open — edit it in the workflow editor.
• Compile — build every job's G-code without sending anything to a machine. See Compile vs run.
• Run — compile, then start a workflow run on Activity.
• View compiled G-code, View history, Duplicate and Delete in its menu.

Duplicate makes a copy with the same steps and settings, pointing at the same job templates, engraving profiles and machines — a quick way to build a variant of a workflow that already works. The copy starts clean, with no compiled G-code and no run history of its own.

The workflow editor

The editor is the canvas, with the Assistant open beside it. There is no Save button: every change is saved a moment after you make it, and the top bar says Saved. A save that fails is retried until it goes through, and if the same workflow was saved from another window in the meantime, nothing is overwritten — you choose which version to keep.

• Add a node on the canvas, or a double-click on it, adds a node by hand.
• Click a node to open its settings, for fine-tuning. Details in the top bar shows the whole workflow at a glance.
• Assistant in the top bar shows or hides the assistant.

The assistant

Tell the assistant the job in your own words — what to engrave or cut, from which files or orders, with what power and speed, how to lay it out, and what should happen when it's done. It builds the workflow on the canvas as you watch, checks that it works, and explains what it did. For example:

• Engrave every SVG in a Library folder, then cut their outlines at full power in two passes.
• Make a 5 × 5 material test: speed from 200 to 1000 mm/min across, power from 20% to 100% down.
• Engrave a name I type each time the workflow runs, centred on a 60 mm round coaster, then cut the circle.
• Read the paid orders from my database, engrave each order on its own and mark it done when it finishes.
• Explain what this workflow does.

While it works, the pane shows each step it takes — looking at a table, trying a query, checking a draft — and new nodes appear on the canvas as they're wired in. Before handing over, it plans the whole workflow as compiling would, so a formula that fails on real data or parts that land off the bed are fixed before you see the result.

• Everything it changes is one step: Undo in the pane (or Ctrl+Z) takes it all back, and Put back restores it.
• Stop ends a request at any point and leaves the workflow as it was before you asked. The canvas is locked while the assistant works; you can still pan and zoom.
• Its replies can be selected and copied.
• Conversations are kept per workflow. Pick up where you left off lists the latest ones, and the history button lists them all — open one to carry on, or delete it.
• Run SQL and typed G-code it writes come with a warning to read them before running. When a workflow needs the database or cloud storage and they aren't set up yet, it says so, with a button to the right settings.

Choosing who answers

Settings → AI assistant picks the provider:

• Included with GRBL Server — the default, and the one paid part of GRBL Server: free for a month, then $3.99/month. No key is needed, and it comes with a monthly allowance. Start the free month, or sign in with your subscription, on the Account page (see Login & accounts). If you use up the allowance, it renews on the 1st of the next month; to keep going before then, pick another provider and add your own key.
• Anthropic (Claude), DeepSeek, Z.ai (GLM), Kimi (Moonshot), or any OpenAI-compatible API at an address you give, such as an EU host or a local Ollama — with your own API key, paid to that provider and free of charge from us. The key is saved encrypted for your Windows user and never shown again. Test the connection checks the key and that the model can use tools.

Node types

Add a node with Add a node or a double-click on the canvas. Every wire carries one kind of data — Files, Records (database rows), a Value, an Operation, a Job or Events — and the editor only lets you connect sockets that fit. Dropping a wire on empty space adds a node already wired in.

Any setting on a node can also be driven by a wire: drag a Value (or Pick value) onto a node and choose which setting it drives, or use the link button beside the setting. The editor's Problems panel lists anything that would stop the workflow from compiling, and anything that's probably a mistake — a job that isn't in the Run order, for instance, never runs.

A minimal workflow

1. Click New workflow and give it a name. The canvas starts with the Run order node.
2. Add a Library folder node. Pick a folder and set Extensions to svg. Show the files it finds confirms the filter.
3. Add a Job node and pick a job template — or, without one, an engraving profile and a machine.
4. Wire Library folder Files → Job Files, then Job Job → a step of the Run order.
5. Compile to check the result; Run to send it. There's nothing to save — it already is.

Or ask the assistant — engrave every SVG in my Signs folder with the plywood template builds the same thing.

A production batch

For a typical sheet of orders:

1. Library folder filtered to Name starts with order_ — today's order files.
2. Job with the template for the material, Layout set to Nesting to pack the parts onto the sheet, and Clip or crop set to the offcut on the bed.
3. A Machine commands node sending your Home macro before the job and parking the head after it.
4. The Job in step 1 of the Run order. Add a second Job for the cut on another machine in the same step to run both at once, or in step 2 to run it afterwards.

Designs, formulas & operations

These nodes let a workflow make jobs that don't exist as files yet — names on tags, serial numbers, labels, material tests — and the assistant uses them whenever a job needs something new.

• Design draws what to engrave: an SVG written into the node, in millimetres, with {{ formulas }} for the text and numbers in it. It makes one design per record of a Database query wired in, or as many as Repeat says. It can also give G-code, run as it is.
• Formula works out a value from the values wired into it — round(width * 2 + gap, 1) — to wire into any setting.
• Arrange sets Copies, X, Y, Width, Height and Rotation for what goes through it, placed by its lower-left corner or its centre. Each can be a number, or a formula worked out for every item: =10 + (index % 5) * 25 puts five in a row, 25 mm apart.
• Operation is one pass of a job with its own engraving profile or settings, and G-code before and after it — air assist on, then off. Wire an engrave Operation and a cut Operation into a job, and it engraves and then cuts in one program, every part in the same place.

A job's own settings

A Job doesn't need a profile or template. It makes its own engraving profile when the workflow compiles — from the defaults, or the profile or template it's based on — plus its own Engraving settings: any setting of a profile, by name. A setting written as a formula is worked out for each item, so a whole material-test grid of speeds and powers is one job. A Job can also:

• Leave the job out when it has nothing to engrave, instead of stopping the compile.
• Be switched on or off by a yes/no wired into Runs.
• Split by a column — one job per order, say, with the run waiting for you between them.
• Show Instructions to the operator on Activity before its step starts — load the 3 mm birch.

Check on a Design, Formula, Arrange, Operation or Job shows what it makes — the designs, where every item lands and whether it fits the machine, each pass's settings — without making any G-code.

Match value

When each product needs its own job template, Match value picks it per order instead of you picking it on every run. Wire in the order's product — a Database query, through a Pick value — list each product code with the job template that engraves it, and wire the node into the job's Job template. It can give engraving profiles, machines, Library folders, text or numbers the same way.

• Values are compared as text, ignoring upper and lower case and spaces at the ends, so a product id 7 from the database matches the 7 typed in the table.
• A value that's not in the table stops the compile with its name in the error, so a new product is never engraved with whichever template came first. Choose Give this instead to fall back to a value of your choosing.
• Test works out what it gives for a value you type, and marks the row it matched.

Values asked when running

Every setting on a node is fixed when the workflow is saved — unless you leave it open. Wire a Value node into the setting and turn on Ask for it when the workflow runs: Compile and Run then ask for it first, using the Value's name as the question, and the answer is used for that run only. Cut the same job from a different folder, at a different sheet width, or on another machine — without editing the workflow or keeping near-identical copies of it.

• The value typed on the node becomes the suggested answer.
• Mark it Required and the workflow won't compile until it's given a value.
• One Value can drive settings on several nodes — one sheet width for two Nesting jobs, say. Use two Values if they should differ.
• Machine, job template, engraving profile and folder Values offer the ones you have now, not the ones you had when the workflow was written.

Compiling never changes the workflow itself. The values show on the compile's progress card, are kept with the compiled G-code, and — for a run — are recorded in the workflow's history.

Database queries & Run SQL

Workflows can read their work from your own database and write results back to it. Connect it once in Settings → Database (MySQL, PostgreSQL or SQLite).

Through an SSH tunnel

A MySQL or PostgreSQL database on a server doesn't have to be open to the internet. Fill in SSH host, SSH user and SSH key path under Settings → Database, and set Host and Port to the database's address as the server sees it — usually 127.0.0.1 and 3306. Every Database query and Run SQL then goes through an encrypted tunnel, opened with the SSH client built into Windows on the first query and kept for the ones after it. The server's identity is remembered the first time, and a changed one is refused. Leave SSH host blank to connect directly.

Database query

• Write the SQL on the node. {{name}} placeholders become input sockets you can wire Values into — WHERE batch = {{batch}} — and a list fills an IN {{ids}} correctly. Text is quoted and escaped for you.
• Test query runs it and shows the first rows. Nothing is changed.
• To use the rows as a job's files, wire Records into the Job and choose the Column that holds the file and what it contains: S3 paths (files in your cloud storage), the SVG itself, or paths of files in the Library. An optional ID column tags each file with its row, so Run SQL can tell which order a job came from.
• To use the rows as values, wire Records into a Pick value node.

Run SQL

Wire a Job's Events output into a Run SQL node and choose when it runs — when the job starts, finishes, fails with an error, is stopped, or is interrupted because the server stopped. {{job.column}} refers to the records of the job that triggered it, for example UPDATE orders SET status = 'engraved' WHERE id IN {{job.id}}. One Run SQL node can serve several jobs. Preview the SQL shows the statement each job will run without running it.

Machine commands

Homing before each step, switching on air assist, or parking the head where the next piece can be loaded shouldn't need a button press between steps. A Machine commands node does it for you:

• Wire a Job's Events output into it — or use Send machine commands… on the Job. One node can serve several jobs; the commands go to each job's own machine.
• Send a macro (any of yours, whether or not the job's profile shows it) or G-code written here, one command per line.
• Send it before the job starts, after the job finishes, or both, with an optional wait before and wait after of up to 60 seconds each — for air pressure to build up or a fan to run on.
• Values in braces are filled in for each job, as in macros: the machine's work area ({width}, {depth}, {height}), the job's edges ({min_x}, {max_x}, {min_y}, {max_y}…), and sums of them such as {max_x-min_x}.

The commands are written into the job's G-code when the workflow compiles, so they reach the machine in the job's own stream and show in its preview. Commands sent after the job wait for its last moves, and the job's origin is put back first, so G0 X0 Y0 means the same after a gridded or nested job as before it. Compiling stops with a reason if a macro is missing, is set for other firmware than the job's machine, or uses a value the job doesn't have.

Compile vs run

Compile evaluates the whole graph — reads the sources, arranges the layouts, nests the parts — and generates every job's G-code without sending anything to a machine. When it finishes, View G-code on the card opens each compiled file in the Job Station like any other job, with the preview, machine controls and macros, so you can check a workflow before it ever runs. Compiling again replaces what the previous compile left. A long compile can be cancelled.

Run compiles, then creates a workflow run on Activity.

Workflow runs

A workflow run works through the steps of the Run order on Activity. Each run shows a progress bar of its steps and the machines involved.

• Start run starts the first step. Jobs in a step are sent in parallel, each to its own machine, and the step is finished once every job in it is done.
• Between steps the run waits for you. Continue runs the next step.
• Skip step moves on without running a step — a cleaning pass that isn't due, a piece already engraved. It asks first, naming the step. Skipped steps are hatched on the progress bar and recorded in the history.
• Control machine opens the jog pad, Home and Unlock, the console and a command box for the machine the next step will run on — before the run starts and between steps, never while a step is running.
• If a Job was left without a machine, pick one on the run card when its step comes up.
• Abort stops the run at any point.

Every run keeps a timeline — created, step started, completed, skipped, failed, aborted, and the values it was run with — under View history on the Workflows page.

What's next

• Build the job templates a workflow uses →
• Choose a grid or nesting layout →
• Clip jobs to your material →