A flow is a branching graph of agent steps: read your measurement, fork on what it says, repeat once per row, stop for a person, write a draft, call another system. You draw the path instead of hoping a model picks it, the whole graph is costed before it runs, and it can run every Monday without you.
A blank canvas is a worse front door than a list of things that work, so the palette opens with whole flows wired from GEO verbs rather than generic ones. Each drops onto the canvas complete, and appends rather than replaces — dropping one onto work in progress cannot lose anything you built.
| Flow | The steps it arrives with | What you get at the end |
|---|---|---|
| Content refresh | Read the page → compare it against the page that wins → branch on whether we are behind → rewrite → lint → approval | A checked rewrite of a page that slipped, or an early exit saying it did not need one |
| Answer what we lose | List lost prompts → read what was said instead, once per prompt → plan → write → lint | A draft that answers the questions engines currently answer without you |
| Why they win | List competitors → list the sources cited → tear each rival page apart → compare how each brand is described → summarise | The three things your pages would have to change to be cited instead |
| A page for a gap | Measured gaps → the brief → what you already say → plan → write → lint → approval | A measured content gap taken all the way to a draft somebody has approved |
Every step above is a real tool on your own data, not an illustration. The palette also holds each step on its own, and a search that covers tool descriptions as well as names — because somebody looking for “Slack” is searching for a word that appears in no tool name.
Beyond the tools themselves — the ones that read your data and the smaller set that write — a graph is built from five shapes. Read-only steps come first in the palette on purpose: the cheap, ungated ones are what a graph should be mostly made of.
A free-text instruction with a typed answer. It runs no tool, so it reaches nothing and writes nothing — useful for turning three earlier outputs into one judgement.
Answers one true/false question and sends the run down the matching wire. This is what lets a flow do nothing when nothing is wrong.
Runs the step once for every row it was handed — every lost prompt, every rival page — and passes the answers on as a list.
Runs nothing itself. The flow halts with the exact next action on screen and waits, however long that takes, including on a scheduled run at 7am.
Sends a request outside MentionBeat. You set the address when you build the flow; the running model cannot read it, change it or redirect it.
A step that only reads is labelled Reads. A step that writes is labelled Writes and carries a mark on the palette before you ever place it. You should not have to run a graph to find out what it touches.
The cost of the whole graph sits beside the Run button and updates as you wire it. An empty canvas reads nothing to run yet rather than a misleading zero, and a step whose price cannot be known says so instead of guessing low.
Flows spend the same credits as measurement and agent runs. There is no automation tier, no per-seat automation fee and no plan that unlocks the canvas — credits are the only limit, on Free as much as on Enterprise.
Each scheduled flow is claimed before it starts, so a crash or a restart mid-run does not produce a second one spending the same credits twice. The next fire is computed from the moment it actually ran, which means a flow that takes an hour can never be immediately due again.
It is the same reasoning as scheduled measurement, applied where the stakes are higher: a flow can spend credits and reach somebody else’s system.
Flows are on every plan, including Free. Drop a working one on the canvas and read what it would cost before you run it.