The flowss Studio Agent and its modes

The flowss Studio Agent is the Studio's own multi-step agent. It lives in the flowss Studio Agent pane on the right of the Studio. Where a Quick change makes one edit in one round trip, the flowss Studio Agent plans the work, calls tools one step at a time (read the diagram, write it, edit it, check it, open another figure), shows you every step as it happens, verifies the result before it says it is done, and leaves you an undo for everything it touched. You choose what kind of specialist runs from a mode picker of twenty-one modes: sixteen single specialists, from Build / edit diagram to the Critic and the Publication preflight, and five pipelines that chain several of them. This page is the complete reference: how to open and drive the pane, every mode and what it may change, the approvals the flowss Studio Agent must ask for, how conflicts and undo work, what is verified, what it costs, and every message you may see. The lighter AI tools around it are on The flowss Studio Agent: prompt and quick help.

Note: The flowss Studio Agent pane's layout is being refined. This page describes what the pane does, its modes, actions and messages; the exact arrangement of controls may differ slightly from what you see.

At a glance

On Windows and Linux, read ⌘ as Ctrl throughout this page.

Opening the flowss Studio Agent pane

The pane shares the right-hand drawer with Collaborate, Comments, Diagram Intelligence and the Diagram timeline; one shows at a time, and a Side panel switcher moves between the flowss Studio Agent, Collaborate and Comments. The drawer reopens on the same pane after a reload. To close the pane, click × (tooltip Close (Esc)), press ⌘E, or press Escape while your cursor is not in a text field.

A tour of the pane

From top to bottom, the pane holds:

The composer

• The mode picker sits at the top of the composer and shows the current mode's icon, name, and a one-line description of what it is for. Pipelines also show how many steps they run. See Choosing a mode.
• The import-URL row appears only in Import to diagram and Update from source. See Importing from a URL.
• The field says what the current mode expects:

The field grows as you type and scrolls once it is tall. Enter adds a new line; ⌘Enter runs. The hint under the field reads ⌘ + Enter to run (or Ctrl + Enter to run), and Working — you can stop at any time during a run.

• The microphone starts dictation into the field. See Voice input.
• Run the flowss Studio Agent (the arrow button, tooltip Run the flowss Studio Agent (⌘ + Enter)) sends the request. It is disabled while the field is empty. While a run is working it is replaced by Stop.

Running a request, step by step

1. Open the pane and, if you need to, choose a mode. The pane starts on Build / edit diagram.
2. Open the figure you want the flowss Studio Agent to start from. The flowss Studio Agent works on the figure that is open when you press Run the flowss Studio Agent.
3. Type the request and press ⌘Enter. Your message appears, the run log opens beneath it, and the header shows Planning….
4. Watch the run log. Each tool step appears as it starts (for example Reading the diagram, Writing the diagram, Verifying the diagram) and is ticked, or marked as needing attention, when its result comes back, with a one-line result beneath it. While the model writes, its words stream in a faint italic preview.
5. Changes land on the canvas as they are made, with a short entrance animation, and the log says what changed, for example "Applied — " followed by a summary of the nodes and edges added or removed.
6. When the flowss Studio Agent finishes, the platform verifies every figure the run produced. The log adds a Checks line and up to three findings, and lists any values the flowss Studio Agent marked as illustrative.
7. The flowss Studio Agent's summary appears as its reply, followed by the undo button that fits the run and up to three Next moves.
8. If the run proposed a change that needs your approval, it appears under Waiting for your approval above the composer. Nothing in it has happened until you approve it.

You can keep working while the flowss Studio Agent runs: switch figures, edit, or open another pane in the drawer. See When you edit while the flowss Studio Agent works.

The run log's words for each step

Plain notes from the flowss Studio Agent appear in the log as quiet lines; a line beginning with "Refused:" means a result was not applied (see Troubleshooting); and in a pipeline, each step starts with a heading such as Step 2/4: Verifying.

Choosing a mode

Click the mode picker to open a searchable, grouped list of every mode.

1. Type in Search modes… to filter. Every word you type must appear in a mode's name, its tag (such as "judge, do not fix"), its one-line description or its group, so "chart", "review", "prisma", "critique" or "export" narrows the list quickly. The search matches those words only, not what a mode knows about: "c4" or "journal", for example, find nothing. When nothing matches you see "No mode matches" followed by your search.
2. Move with ↑ and ↓; PageUp and PageDown (or ⌘Home and ⌘End) jump to the first and last mode.
3. Press Enter or click to choose. The picker closes and the mode applies to your next run.
4. Escape closes the list without changing anything; Tab closes it and moves on. From the closed picker, ↑ or ↓ opens it.

The mode cannot be changed while a run is working (the picker's tooltip says "The mode can't change while the flowss Studio Agent is running"). Your choice lasts while the drawer is open; when you close the drawer and open it again, the picker starts on Build / edit diagram.

The list has three groups, in the order work usually happens:

Mode reference

Every mode in one table

"Edits your work" says whether the mode can change your figures. Read-only modes judge and report; they are never given the tools to write. "Steps" is the most tool steps one run may take. Costs are hosted AI points; on your own key no points are spent.

The four deep specialists (Framing analyst, Critic, Methods & statistics review and Conductor) reason longer, on a more capable model tier, because their mistakes are structural and expensive to catch; that is why they cost 47 points rather than 8.

Which tools each mode is given

A mode asked to use a tool it does not have is refused by the platform, whatever the request says. A read-only mode therefore cannot change your figure even if you ask it to; switch to a mode that edits.

Every mode shares the same working rules. It builds what you asked for and what your request directly implies, and nothing added just to look complete; anything it had to infer is marked "(assumed)" in the diagram. It never presents a number, citation, study or name it was not given as fact: missing values become visible placeholders such as n = ? or TBD, and any value it invents to show the shape of a figure is labelled "(illustrative)" in the figure itself and listed in its summary. It decides small, reversible choices itself and mentions them in the summary rather than stopping to ask. It re-reads its work before finishing, and ends with a one- or two-sentence summary and three specific next steps.

Build / edit diagram

The default, general-purpose mode. It builds a new diagram from a description or edits the one in front of you, choosing the engine that fits the request.

• Use it for anything you would describe as "draw", "add", "change", "turn this into".
• How it works. A brand-new diagram, or a change to most of one, is written whole; a small change (add a node, rename a label, fix an edge) is a targeted edit so the rest of your work is untouched. When a request clearly calls for several diagrams (a full C4 set, a diagram plus its chart) it creates one figure per diagram; otherwise it edits the open figure.
• May change the open figure, other figures and the engine. It deletes a figure only when you clearly ask, and that deletion waits for your approval.
• You get the diagram, a short summary and three next steps.
• Try: "Build a C4 container diagram for a food-delivery app, then add a payments service", "Turn this into a sequence diagram of the login flow with error paths", "Draw the AWS architecture for a serverless image pipeline (S3 → Lambda → DynamoDB)", "Model an order state machine: cart → paid → shipped → delivered, with cancellations" (these four are the pane's own examples).

Import to diagram

Turns whatever you paste (source code, SQL or DDL, JSON, logs, an outline, prose) into the clearest diagram or diagrams for it.

• Use it for "here is my code / schema / data, show me".
• How it chooses. Code or architecture becomes a flowchart, a C4 view or a D2 diagram; SQL or DDL becomes an entity-relationship diagram (DBML or a Mermaid ER diagram); a process becomes a sequence diagram or BPMN; tabular data becomes a chart (Vega-Lite or Plotly); a state machine becomes a state diagram. It realises every meaningful entity and relationship rather than summarising them away, and notes its choice in the summary.
• May change the open figure, which it replaces with the import, and it may add one new figure per extra view.
• Also imports straight from a public file URL. See Importing from a URL.

Tip: Import writes over the open figure. To keep it, create a new figure first (⌥⌘N), then run the import there.

Data & charts

A data-visualisation specialist that chooses the chart that tells the truth about your numbers, then builds it.

• Engines it uses: Vega-Lite first; Vega for radial, sunburst, force-directed or parallel-coordinate views; Plotly for publication and scientific plots (3-D surfaces, contour, polar, ROC, Kaplan–Meier, dose–response, violin, asymmetric error bars, log scales); and the single-purpose engines when the shape is the chart: Sankey, funnel, waterfall, treemap, Marimekko, bullet, calendar heatmap, flame graph, word cloud, quadrant, choropleth and chord.
• How it chooses: bars for comparisons (horizontal for long labels or many categories, sorted unless the order means something), lines for change over time, histogram, box or violin for distributions (raw points when n is small), scatter with a trend layer for relationships, stacked bar or treemap for parts of a whole (a pie only for two or three slices), Sankey for flows, funnel for staged drop-off, quadrant for two dimensions of importance, and error bars or bands for uncertainty.
• Rules it holds: bar charts start at zero; axes carry units; n is stated; colour carries meaning (sequential, diverging or categorical, at most about seven categories). It never invents data; illustrative values are labelled in the figure.
• Checks: runs the science checks on any measurement, statistic or citation in the labels, and fixes what fails.
• May change the open figure and add figures (a distribution plus a trend instead of a dual axis).
• You get the chart and a summary naming the encoding it chose.

Evidence & synthesis

A research methodologist that builds the figures a review, protocol or paper needs, from the evidence you supply.

• Engines and the standards they serve: PRISMA 2020 flows (prisma); CONSORT, STROBE and any flow whose numbers must reconcile in FlowScript (it puts a citation on every count you give it, and several figures share one FlowScript document); causal DAGs (causaldag) before any adjustment argument; Plotly for forest plots, funnel plots, Kaplan–Meier, dose–response and ROC (ratio measures on a log axis); Vega-Lite for subgroup panels and risk-of-bias heatmaps; Mermaid for logic models and search strategies; argument maps; and Venn diagrams for overlapping sources.
• Rules it holds: estimates come with their uncertainty; PRISMA counts must reconcile; study designs are distinguished; risk of bias and GRADE certainty are named where the data supports it. Its single most important rule: it never fabricates a study, an effect size, a citation or a count. Without numbers it builds the structure with placeholders or clearly labelled illustrative values.
• May change the open figure and add one figure per figure needed (flow, forest plot, DAG).
• You get the figures and a summary that flags every assumed number. The same specialist is offered in the Lab; see Lab.

Framing analyst

Settles what is being made before anything is drawn. It never builds.

• Use it for a request you are not sure how to pitch: "a diagram of the payment system" can be four different diagrams depending on who reads it.
• How it works. It reads what exists, asks the platform for a realistic route through the studios (Planning the work), and writes a brief.
• The brief is its summary, and has eight parts: Deliverable (the one artefact, named), Reader (who opens it and what they know), Decision (what someone does differently after reading it), Notation (the engine, and why it beats the runner-up), Altitude (one level), In scope / out of scope, Wrong if (two or three things that would make it wrong rather than ugly) and Checked by (how correctness will be established). Minor choices are made and marked "(assumed)"; at most one question is asked, and only when the answer would change the deliverable.
• Changes nothing. The first of its three next steps names the specialist and studio that should build it.
• Costs 47 points (deep specialist). Use Frame → Build to brief and build in one go.

Science (engines)

A scientific-figure engineer for biology, chemistry, physics and mathematics that renders science at high fidelity with the purpose-built engines.

• Engines it reaches for: Newick for phylogenies, pedigree charts for inheritance, anatomy diagrams, causal DAGs for epidemiology, Mermaid for biological processes and reaction mechanisms, 3-D molecules (mol3d), phase diagrams, KaTeX for equations and rate laws, free-body diagrams, circuits, astronomy (orbits and HR diagrams), digital logic, Plotly and Vega-Lite for quantitative plots, Venn diagrams for sets and Graphviz for graphs and automata.
• Rules it holds: units consistent and stated; equations balanced; taxonomy and pathway directions correct; force vectors pointing the right way; no invented data.
• Checks: before finishing any figure that states a reaction, a relation, a measurement or a citation it runs the science checks (equations balanced for mass and charge, with corrected coefficients when they are wrong; real element symbols with molar masses; dimensional analysis; precision; physical constants against CODATA; identifiers by their check digits) and fixes every failure.
• May change the open figure and add one figure per panel (for example a mechanism and its rate law).
• For illustrated icon figures, use the Science studio instead. See Science.

Systems architect

A staff-level systems architect that models software and infrastructure at one altitude, in the notation that fits.

• Engines it uses: D2 for system and service maps; Structurizr for the C4 model when more than one level of zoom is needed (one model, several consistent views); Mermaid for C4 blocks, sequence diagrams and pipelines; Graphviz for large dependency graphs; DBML for the data model; PlantUML for UML house styles; rack and network diagrams for physical layouts; attack trees for the threat model.
• The mistake it prevents: mixing levels. It picks one C4 level (context, container, component or code) and stays there, building one figure per level when your request spans several.
• Rules it holds: every element is a noun with a responsibility; every edge is a verb with a direction and, where it matters, a protocol ("publishes OrderPlaced to Kafka"); technologies are named; trust, network and ownership boundaries are shown; external, third-party and legacy parts are marked. Commonly forgotten concerns (authentication, cache, queue, storage, CDN, observability, scheduled jobs) are asked about or added marked "(assumed)", never presented as yours.
• You get the diagram or diagrams and a summary naming the level drawn.

Teaching specialist

An instructional designer who builds diagrams whose job is to make someone understand.

• How it differs from Build: a teaching diagram is sequenced, not complete. It keeps each view to roughly five to nine elements, and builds a progression of figures that adds one idea at a time when a concept is bigger than that.
• Rules it holds: layout, grouping, direction and colour each mean something; every relationship is labelled with the verb that makes it true ("catalyses", "is a special case of"); it shows the boundary case that is not an instance; it names a well-known misconception beside the correct model; it uses the purpose-built engine for anything with real structure (anatomy, circuits, forces, phylogenies, molecules).
• Accuracy: it never invents a step, a date, a term or a figure, and names any simplification it made in its summary ("shown as a single step; in reality this is three enzymatic reactions").
• You get the view or views, plus next steps that deepen understanding (a boundary case, a worked example, a self-test). For full lessons and practice, see Study.

Review & fix

Reviews the current diagram, or each relevant figure in a multi-figure workspace, and fixes what it finds in the same pass.

• What it looks for: missing entities or edges, wrong directions, unlabelled relationships, duplicated or contradictory nodes, awkward layout and syntax errors.
• How it fixes: with the smallest targeted edits that resolve real problems, preserving your intent.
• You get a summary that names the issues it corrected, and three next steps.
• Reach it from ⌘K flowss Studio Agent: review & fix the diagram, and from Fix beside a finding in the status popover (which asks it to fix only that one finding).

Tip: Review & fix finds and repairs in one go, so you do not see the problems before they are changed. If you want the judgement first, run the Critic, then the Refinement pass, or use the Build → Verify → Critique → Refine pipeline.

Update from source

Brings an existing diagram back in line with a changed source of truth (updated code, a changed specification, or your description of what changed), with the smallest change that makes it correct again.

• How it works: targeted edits wherever possible, preserving node ids, manual layout, groupings, labels and annotations; it adds, removes or renames only what actually changed, and rewrites the whole diagram only if it is genuinely broken.
• You get a one-paragraph summary of exactly what changed ("added X, removed Y, renamed Z"). If nothing material changed, it says so and makes no edits.
• From a URL: paste the source file's address in the URL row. See Importing from a URL.

Critic (judge, do not fix)

Reads finished work the way the person who will reject it reads it, and reports. It never edits.

• How it works. It first runs the quality read with your original request, which scores seven dimensions (fidelity, completeness, structure, legibility, rigour, accessibility and portability), simulates every colour pair under protanopia, deuteranopia and tritanopia, checks the palette in greyscale, and checks that numbers your request named actually appear. It then verifies that the figure parses. Finally it adds what no checker can see: is the abstraction right, is anything asserted that is not true (an arrow claims causation, a boundary claims ownership), what is missing that a reader will assume is absent on purpose, what a hostile reviewer would open with, and does the figure hold one altitude.
• A finding names the element, says what is wrong (not what it would have preferred), states the consequence, and gives the fix in one clause. Findings are ranked by how much they would change the work.
• You get a one-sentence verdict, the ranked findings, and what it could not judge; its three next steps are the three most valuable fixes. When the work is strong, it says so.
• Costs 47 points (deep specialist).

Methods & statistics review

The colleague you show a scientific figure to before you submit it: a methodologist and statistician who reviews like a demanding but fair peer reviewer, and fixes what can be fixed.

• Is it true? It runs the science checks first, fixes every failure using the corrected text where one is supplied, and runs them again.
• Is it supported? Is n stated (and is it independent replicates, not technical measurements)? Are error bars defined as SD, SEM or a confidence interval? Are tests named, with plausible assumptions? Is a p-value reported without an effect size? Is something called "significant" without a test? When a study is described, it runs the study-design check with only what you actually told it, which computes the minimum detectable effect at your n, the family-wise error rate across primary outcomes and the design effect of analysing at a finer grain than randomisation, and lists what it could not assess.
• Is it honest? Truncated bar-chart axes, dual axes chosen to make curves cross, "trending toward significance", bar charts of means where the distribution matters, a regression line through five points, a correlation drawn as a mechanism.
• Is it reproducible? Units, conditions, organism or cell line, instrument and software versions, data source.
• Models: when the figure is a model drawn on a Science canvas, it computes it and cites every number by its ledger id; a number no tool gave it is never stated.
• May change the figure with targeted edits (a missing unit, an unlabelled axis, an unbalanced equation, an undefined ±, a caption without n). Judgements only you can make (which test was really run, what the error bars really are) are put to you as questions.
• Costs 47 points (deep specialist), with up to 16 steps.

Publication preflight

The last check before someone who did not make the figure opens it: will it survive leaving here?

• How it works. It runs the quality read (whose accessibility and portability scores are its remit), verifies the figure, and runs the publication check, which measures the figure against a destination: width in millimetres against the column, the smallest type at final size, stroke weights, raster resolution, the number of type sizes, colour ramps whose lightness reverses, series told apart by hue alone, and anything loaded over the network.
• Destinations. Name your journal in the request. It knows 29 profiles: Nature, Nature Portfolio, Science, Cell, PNAS, NEJM, JAMA, The Lancet, The BMJ, PLOS Biology, PLOS Medicine, eLife, generic Elsevier, Springer, Wiley, Frontiers, MDPI, ACS, RSC, AGU, Oxford University Press and Taylor & Francis journals, IEEE Transactions, IEEE conference papers, ACM, Physical Review (APS), arXiv, an A4 thesis and an A0 conference poster. You can also say single, one-and-a-half or double column, or the page's maximum width; single column is assumed when you do not say. Without a destination it applies the floors that hold everywhere and says which it assumed.
• The constraints it applies: single column about 85 mm, one-and-a-half about 114 mm, double about 174 mm; nothing below about 5 pt at final size; text contrast at WCAG AA or better; a palette that survives all three colour-vision deficiencies and greyscale (or a second channel such as dashes, markers or direct labels); every asset embedded; alt text of one sentence under about 150 characters.
• May change only mechanical things: a colour swap, a direct label instead of a legend, an embedded asset. It does not restructure your content, and says what it could not fix and what that costs.
• You get a verdict (submittable, submittable with warnings, or not yet), what it changed, what remains, and an export recipe: the format (SVG for vector, PNG at 300 dpi or more for raster, PDF for LaTeX), the target width in millimetres, and the alt text written out ready to paste.

Refinement pass

Acts on a critique and proves that it worked: the smallest set of edits that raises the weakest scores, and the numbers afterwards.

• How it works. It uses a critique you paste, or runs the quality read itself with your original request. It takes the top findings in order, edits surgically (preserving ids, manual layout, groupings and your wording), then re-runs the quality read and reports the change, for example "Completeness 50% → 85%, accessibility 55% → 100%, overall 71% → 92%". It stops when the score stops moving and tells you which remaining findings need judgement rather than edits.
• It never redesigns (no re-layout, engine change or restyle nobody asked for), never fixes a finding by deleting the thing it was about, and never claims an improvement it did not measure.
• You get the before and after numbers, what it changed and what it deliberately left.

Tip: Run the Critic first and then the Refinement pass with "Act on the critique above", or let the Build → Verify → Critique → Refine pipeline do both.

Verifier (adjudicate, do not fix)

Somebody else built this; the Verifier says whether it is sound, and nothing else. It never edits.

• How it works. It lists every figure it can see and checks each one: the mechanical verification, the science checks for any figure carrying an equation, a measurement, a statistic, a citation or a pathway, and the quality read.
• A verdict per figure: sound, or not sound with the specific defect and the edit that clears it, for example a node an edge names but that is never declared. A blocking defect is never softened because the rest is good; a figure it could not check is reported as unchecked, never as passed.
• You get a one-line overall verdict (how many figures, how many sound), the per-figure findings, what went unchecked, and the three highest-value repairs as next steps.

Conductor (multi-studio)

The one specialist that knows the platform has nine studios. It handles requests that span several: build it, check it, then teach it; evidence before a claim; one model at three levels of zoom.

• How it works. It asks the platform for a realistic route, then states its plan in one short paragraph before starting, so you can stop it and redirect. It builds the parts that belong on the Studio canvas itself, one titled figure per artefact. For a stage that belongs in another studio it builds the artefact in the closest engine that studio can open (for example FlowScript for a CONSORT flow) and names the handoff in its summary, saying what to open and why; it does not move you to another studio itself. It verifies each substantial artefact as it goes.
• Order and judgement: evidence before claims, structure before detail, correctness before teaching. A request that is genuinely one diagram stays one diagram; it prefers three excellent artefacts to seven adequate ones.
• You get the set of figures, a summary listing what it built and any handoff you should make, and three next steps. See Moving work between studios.
• Costs 47 points (deep specialist), with up to 20 steps.

The pipelines

A pipeline runs several specialists one after another over the same figures. The first step receives your request and your conversation; each later step receives a fixed instruction, your original request, and what the earlier steps reported, as information rather than instructions. The run log marks each step (Step 1/4: Building), and the header shows the step in progress (Verifying… (step 2/4)). Each step gets a fair share of the run's 300 seconds, at least 20 seconds, so an early step cannot starve the later ones. At the end, all the steps' summaries are joined into one reply.

If a step fails, the pipeline stops there but keeps the work of the steps that finished: the reply says how far it got ("2 of 4 steps completed before the flow stopped.") and the error is shown as the run's result. The failed step's own partial edits stay on the canvas, and the undo buttons cover the whole run.

Working with several figures

The Studio holds several figures, and the flowss Studio Agent can work across them.

• What it sees. Every figure in a workspace of up to 40. In a larger workspace it sees a window of 40 consecutive figures, in the switcher's order, that always contains the one you have open: the first 40, or, if your open figure lies further down, the 40 ending at it. Figures outside that window are never sent and never touched.
• Where it works. It starts on the figure that was open when you pressed Run the flowss Studio Agent. It can create figures (they appear in the switcher and the flowss Studio Agent moves to them), switch between figures, and rename them.
• Following it. While you stay where you are, the canvas follows the flowss Studio Agent to whichever figure it is working on. If you switch figures yourself during a run, you stay where you chose, and the flowss Studio Agent's changes keep landing on its own figure in the background.
• Figures you add during a run are kept, whatever the flowss Studio Agent returns.
• The last figure is never deleted.
• Very large figures. A figure whose source is over 60 KB is withheld from the flowss Studio Agent: it is not shown to the flowss Studio Agent, and comes back exactly as it was. If the open figure itself is over 60 KB, the run stops at once with "That diagram is … KB — too large to send to the agent (limit 60 KB). Split it into several figures, or edit it directly."

Importing from a URL

In Import to diagram and Update from source, a row above the field takes a file address.

1. Choose Import to diagram (to diagram a file) or Update from source (to update the open diagram from a changed file).
2. Paste the address into the row ("…or paste a public file URL (GitHub, Gist, GitLab)", or "…or paste a source URL to update from").
3. Press Enter or click Import (tooltip Fetch the file and turn it into a diagram). The request reads "Diagram the source at …" or "Update the current diagram from the source at …" followed by the address.

What can be fetched:

The fetched file is treated as material to diagram, never as instructions to the flowss Studio Agent. If the fetch fails, the run does not start and nothing is charged.

Approvals: changes that wait for you

Most of what the flowss Studio Agent does happens in front of you and can be reverted. A few kinds of change could remove work you would not notice was gone, so the flowss Studio Agent is not allowed to make them on its own. It proposes them instead, and nothing happens until you approve.

These do not need approval: any change to the figure you had open (it happens in front of you, and Revert this run hands it back), renaming a figure, and changing or deleting a figure the flowss Studio Agent created itself in the same run.

What happens during the run

1. The flowss Studio Agent's change is held, not made. Its step in the run log reads "Awaiting your approval · " followed by the proposal.
2. The flowss Studio Agent is told the change did not happen, that it must not try another way to make the same change, and that it must leave that figure alone for the rest of the run. It carries on with the rest of your request.
3. The final reply begins with "(1 change is waiting for your approval — it has not been applied.)" (or "(3 changes are waiting for your approval — none has been applied.)" for several), followed by "The agent's summary, which includes what it proposed:" and the flowss Studio Agent's own summary. The platform's sentence comes first so that a summary written in the past tense ("Removed the old roadmap") is never read as done.
4. Each proposal appears under Waiting for your approval above the composer, with Approve and Reject. The buttons are disabled while a run is working.

Approving or rejecting

• Approve (tooltip Apply this change) applies exactly the change you were shown, and only if neither the proposal nor its target has changed since. An approved change becomes part of the run, so Undo flowss Studio Agent changes takes it back with the rest. The log then reads, for example, "Approved — deleted “Payments”." or "Approved — “Payments” now holds the agent's version."
• Reject withdraws the proposal. Nothing was applied, so nothing needs undoing: "Rejected — “Payments” was left exactly as it is."
• Re-run. If you have changed the target since the proposal was made, it can no longer be approved as it stands: the notice reads "“Payments” has changed since the agent proposed this, so it can no longer be approved as it stands.", and the buttons become Re-run (tooltip Ask again, against the diagram as it is now), which runs the same request in the same mode (fetching a URL again if it came from one), and Dismiss.

Proposals live in the open pane. If you close the drawer with proposals still waiting, they are withdrawn and the conversation records it: "A change the agent proposed was withdrawn when this panel closed — nothing was applied. Run the request again to be asked again."

A change to a figure that was withheld from the flowss Studio Agent for size is never offered: the log says "The agent's change to “…” was not kept: that diagram is too large to send to the agent, so it could not see what it would have replaced. Nothing was changed." A proposed deletion of such a figure is offered with its real size.

When you edit while the flowss Studio Agent works

You do not have to wait for a run to finish. The flowss Studio Agent never writes over an edit you made while it was working.

• A figure only the flowss Studio Agent changed takes the flowss Studio Agent's version.
• A figure only you changed keeps your version.
• A figure you both changed keeps your version. The flowss Studio Agent's version is offered in a notice titled You changed it too: "You edited “…” while the agent was working, so your version was kept." Choose Use its version (tooltip Replace your version with the flowss Studio Agent's) to take it, or Keep mine to dismiss the offer.
• A figure the flowss Studio Agent deleted but you edited is kept: "The agent removed “…”, but you edited it while it worked, so it was kept." Remove it deletes it after all; Keep mine keeps it.

Choosing the flowss Studio Agent's version is recorded with the run, so ⌘Z and Undo flowss Studio Agent changes can bring your version back. If the figure has gone by the time you choose, you see "Can't apply — “…” is no longer open."

Undoing what the flowss Studio Agent did

Every run that changes something leaves you a way back. Which button you see depends on what the run did.

How Undo flowss Studio Agent changes behaves:

• It never overwrites your work. A figure you have changed since the run is left alone and named: "Undid the agent's changes — 2 diagrams put back, 1 it added removed. Left “…” as it is — you have changed it since."
• It covers changes you approved and versions of the flowss Studio Agent's that you chose in a conflict, because those became part of the run.
• It is for the most recent run only, and lasts until you reload the page or open a different workspace. It survives closing and reopening the drawer.
• It cannot be used while a run is working.

For anything older, open the figure's Version history… (⇧⌘H). See Version history and undo.

Verification, findings and illustrative values

Verification before the run closes

When a mode finishes, the platform verifies every figure in the run, not just the open one: does each source parse in its own notation, is it complete rather than cut off, do its references resolve, and does the engine's own analysis flag anything blocking. If something blocking is found, a mode that can edit is sent back to fix it, at most twice. If problems remain after that, you still get the work, and the reply ends with a note such as "(Note: 1 diagram failed verification — please check it.)". Read-only modes are not sent back, because they have nothing to fix with.

Runs that end without finishing cleanly (out of steps, out of time, or stopped after a plain answer) are verified too, and carry the same note when something is wrong.

Findings in the run log

After a run, the log adds a Checks line with a summary, followed by up to three findings, errors first. A line starting with ✗ is an error; one starting with • is advisory. In a workspace of several figures each finding names its figure. These are the same findings, in the same words, that the editor and the status popover show.

Illustrative values

When the flowss Studio Agent had to invent a value to show the shape of a figure, it declares it. The log lists them under Illustrative values — not data, one per line with the reason (up to eight), and the figure itself says so where it will travel:

• In Mermaid flowcharts, Graphviz, Vega-Lite, Vega, Plotly, Science studio boards and FlowScript, a visible note reading "Illustrative values — not data" (followed by the values, cut short at about 240 characters) is written into the figure if the flowss Studio Agent did not already add one.
• In other engines (including other Mermaid diagram types and Weave boards), or where a note would stop the figure rendering, the figure's title gains "(illustrative)" and the reply says which values were invented.
• A run that changed nothing (for example the Critic) never writes a note; its reply and the list are the disclosure.

Stopping, time limits and step budgets

• Stop. Click Stop (accessible name Stop the flowss Studio Agent run) at any time. The reply reads "Stopped.", anything already applied stays on the canvas, and the undo buttons are offered.
• Closing the drawer stops the run. Closing the drawer (×, ⌘E, or Escape) mid-run stops it, as Stop does. Switching the drawer to Collaborate, Comments, Diagram Intelligence or the Diagram timeline does not: the run carries on in the background.
• Time limit. A run may take up to 300 seconds. At the limit it is stopped with "The run hit the 300-second time limit mid-step, so it was stopped. Anything already applied is still on the canvas." or "The run reached its time limit. Anything already applied is still on the canvas."
• Step budget. Each mode has a maximum number of tool steps (see the mode table). A run that uses them all ends there and is verified like any other.
• Long outputs. If a step's output is cut off because it is too long, that output is discarded, never applied half-written, and the flowss Studio Agent is asked to make the change in smaller pieces.
• One run at a time. While a run is working, the composer's button is Stop, and requests sent from elsewhere (the prompt island in Agent mode, a suggestion chip, a ⌘K command, Fix in the status popover) are not queued and do not start. Their text is placed in the composer instead, replacing anything you had typed, so you can run it with ⌘Enter once the current run ends.

The conversation

• Memory. The flowss Studio Agent remembers the last eight messages of the conversation (your requests and its replies, not the run logs), so follow-ups such as "now add error handling to it" work. Each message is limited to 6,000 characters.
• Where it is kept. The conversation is kept in this browser tab. It survives closing and reopening the drawer and reloading the page; a new tab or window starts empty.
• The run log shows only the most recent run; earlier requests and replies stay in the conversation.
• Clear (in the header) erases the conversation, the run log, suggestions, conflicts and proposals, and starts the flowss Studio Agent's memory afresh. It does not undo anything on the canvas.

Which AI provider runs the flowss Studio Agent

How deep a run goes depends on the provider behind it.

In single-pass mode the flowss Studio Agent cannot create, switch, rename or delete figures; it works only on the figure that was open when you pressed Run the flowss Studio Agent.

Cost and metering

Each run is priced when it starts, from the specialists it will use: 8 points for a standard mode, 47 for a deep specialist (Framing analyst, Critic, Methods & statistics review, Conductor), and the sum of the steps for a pipeline. The price is held from your balance while the run works, and settled when it ends:

On your own key no points are spent, but agent runs count towards a daily fair-use ceiling of 300 agent runs (within 1,000 AI requests a day). It resets at midnight UTC, and a run refused at the ceiling is never sent to your provider.

Your account page lists your last 20 agent runs under Agent runs (times in UTC), with When, Agent (the mode or pipeline name), Outcome (Completed, Failed, Stopped, Timed out, Running, or Did not finish) and Points charged. See AI points and limits and Account settings and your data.

Agents in the other studios

Every bespoke studio has a named agent of its own, in a pane built on the same parts: the same run log, approvals, conflict notice, Stop, Next moves and Revert this run. The pane is titled with the agent's name, and the subtitle names the studio's resident specialist, which writes the studio's own format.

What is different from the flowss Studio Agent's pane:

• One document. These panes work on the one document in front of you, so the studio's agent cannot create, switch or delete documents, and the only approval it can ask for is a change to that document (in Weave, removing more than two shapes or connectors).
• Images. You can attach an image for the agent to read (a screenshot, a whiteboard photo, a reference figure) with the image button, or by pasting one into the field. PNG, JPEG, WebP and GIF are accepted, and large images are reduced to 1,400 pixels on the longest side. The composer names the agent, for example "Image attached — the flowss Weave Agent will read it when you run." An image adds 2 points to a hosted run; if it cannot be analysed the run continues without it ("The attached image could not be analysed; continuing without it.") and those points are not charged.
• Edits while it works. If you edit the canvas during a run, your version is kept, for example "You edited the canvas while the flowss Weave Agent was working, so your version was kept — its version is offered below." with Use its version and Keep mine. On boards where the two can be combined, the agent's change is merged around yours: "Applied alongside the edits you made while it worked".
• Revert this run (tooltip Undo everything this run changed) takes back only what the run changed where the format allows, keeping your later edits (for example "Reverted the flowss Weave Agent's changes and kept the edits you made since."); otherwise it explains why it cannot.
• Separate conversations. Each studio keeps its own conversation with its own agent.

Tips

• Pick the mode before you type: the placeholder tells you what the mode expects, and the picker's search finds a mode by the words in its name and description ("chart", "prisma", "critique", "export").
• For anything going to a journal, run Build → Verify → Preflight and name the journal in your request; you get the figure, a verdict and an export recipe with alt text.
• When you are not sure what to build, run Frame → Build, or the Framing analyst alone to get the brief without spending a build.
• Want to see problems before they are fixed? Use the Critic (or the Verifier), read the findings, then run the Refinement pass.
• Give the flowss Studio Agent the real numbers. Every specialist refuses to invent data, so without numbers you get placeholders or labelled illustrative values.
• Make a new figure (⌥⌘N) before Import to diagram if you want to keep the open one.
• Leave the pane open until a long run finishes; closing the drawer stops it. Switching the drawer to Comments or Collaborate is fine.
• Use Next moves: they are the flowss Studio Agent's own three best follow-ups and run with one click.
• Check your account page's Agent runs list to see what each run cost and how it ended.

Limits and known constraints

• Free has no AI. Starter runs the flowss Studio Agent only on your own key; hosted runs need Plus, Ultra or Enterprise.
• One run at a time; requests sent while a run is working are not queued (their text waits in the composer).
• A request may be at most 6,000 characters; the flowss Studio Agent remembers the last eight messages.
• The flowss Studio Agent sees at most 40 figures around the open one, and never sees a figure over 60 KB.
• Runs stop at 300 seconds and at their mode's step budget (8 to 20 steps).
• Closing the drawer stops a run in progress and withdraws any proposals waiting for approval.
• Revert this run is lost when the drawer closes (Undo flowss Studio Agent changes remains); Undo flowss Studio Agent changes covers only the latest run and does not survive a page reload.
• The mode picker returns to Build / edit diagram each time the drawer is opened afresh.
• The conversation is kept per browser tab, not across devices.
• On an own key from a provider other than Anthropic, the flowss Studio Agent runs a single pass without tools.
• URL import accepts one public text file of up to 256 KB from GitHub, Gist, GitLab, Bitbucket or Codeberg.
• The flowss Studio Agent's pane does not take image attachments; the other studios' panes do.
• The model-computing tools work on models drawn as Science canvases; on other engines they report that there is nothing to analyse.

Troubleshooting

Related pages

• The flowss Studio Agent: prompt and quick help
• The Studio editor
• Choosing an engine
• Importing and converting
• AI in flowss
• AI points and limits
• Bring your own AI key
• Version history and undo
• Moving work between studios
• The work model
• Engine reference
• Keyboard shortcuts