Workflows

A workflow = task + frame + work split + search. Write the task and the AI builder reads the frame (the document to fill and the functions that put values into it), splits the work into units, and gives each unit search nodes for where and how to find its data. Run it and workers find the data as the search nodes say, refine it and put it into each field right away. You can start without knowing where the data is — pin the places a run actually used as search nodes and the workflow fills in as it goes. New workflows are of this kind.

Create — “New workflow” in the list opens the “New workflow” window: a name and a purpose (the task; may be left empty). Every new workflow is this kind. A workflow that already has a frame and a split opens in the Run tab; clicking a node there switches to Build.
Layout — two header tabs, “Build” and “Run”, and a trash icon at the right end to delete the workflow. In Build the side panel is the AI builder chat until you click a node on the canvas; then it shows that node’s settings (only the fields it needs). Click × or empty canvas to go back to the chat. Add nodes with “+ Unit” · “+ Search” at the top left of the canvas; wire them only on the canvas. Undo · Redo next to them (⌘Z · ⌘⇧Z, Windows Ctrl+Z · Ctrl+Y — outside text fields) step back through your edits and what the AI builder put in, while the app is open.
AI builder — an AI chat panel. Say what you want done and attach the document to fill and the data to use (drag from the Files tab or the files drawer, or pick with @ — bring files from your computer into the Files tab first). The AI sums it up as a build proposal card (task · frame · where to look · note). The task holds only what to do and its conditions; attached data becomes search node targets, not task text. “Approve and build” writes the task and frame into the workflow, then a main agent reads the frame and a build agent splits the work and places search nodes. Meanwhile the card shows “Building… step · elapsed” and progress notes; when done “Built — n units”, and if it fails “Build again” · “Close”. Nothing runs; the result is drawn on the canvas as units. “Dismiss” changes nothing. One conversation per workflow (also listed in the Chat tab as “Workflow”).
Start · Result nodes — click Start to edit the name and task. Click Result to see the document to fill (hwp · hwpx · xlsx · docx · pptx · html) and find another by name. If it already has a form that form is used; otherwise the AI builder or a run finds its fields.
Units — nodes are Start (task) · search · units · Result (frame). Wiring units sets their order, so a later unit sees what an earlier one put in. Click a unit to edit its name · fields (click a chip to give it to this unit — each field belongs to one unit; dimmed chips belong to another) · extra instructions. Drag to move; remove with Delete · Backspace or the trash icon in the side panel.
Search — dashed nodes in the row above the units. A method (search documents · search the web · ask a teammate) + a target (document · folder · site · teammate) + what to look for. Connect a search node to a unit and that unit searches only that way, starting at the target. Leave the target empty and the searcher decides within that method at run time; a unit with no search looks anywhere (documents · web). Asking a teammate goes through that person’s approval and the values go in without the AI seeing them (it is that unit’s only search). Leave the teammate empty (“Whoever on the team has it”) and each online teammate’s device first checks its own shareable files for those items (only item names come back); approval is then requested from whoever has the most — if they decline or don’t answer within 30 minutes it goes to the next one who has it, and teammates who were offline are asked if they come online within 30 minutes. Turn on “Ask everyone” to ask every teammate for that unit’s table cells and put one row per person into a single table (like everyone’s name and contact). Rows from people who don’t approve within 30 minutes are left out and their names are noted in the summary. Click the node to edit its method (“Docs · Web · Teammate” — Teammate only when you have teammates) · where · what to look for. Which units use it is set by wiring the search node to units on the canvas.
This case — a workflow is a procedure you repeat for many cases; one run is one case. “This case” at the top of the Run tab shows only the fields a person gives — this case (changes every run — starts from the last case’s value, changed fields get a line on the left) · fixed (always the same, stored in the workflow) · auto (“Auto · today” — today’s date). The other fields (search · AI writes · leave blank) open under “other fields”; change any field’s mark with the picker on its right. “Leave blank” keeps a function outside the task’s scope (e.g. pages 3+) empty — the build AI decides it from the task, and it is left out of the summary and report counts. Paste the request you received (mail · memo) and the AI splits it into the fields; drop a document and it becomes this case’s material — empty-target document searches look there. Paste a table copied from Excel · Sheets, or drop an xlsx · csv (when its header row matches field names), and each row becomes a case — “Run N cases” runs them together (up to 50 at a time). The build AI moves concrete values written into the task (recipient · date …) into this-case fields and keeps only the procedure in the task. As runs pile up, fields that changed every time are marked this case and fields that were always the run’s date are marked auto (always-same values are suggested as fixed); fix a wrong mark with the picker. The header icon previews the document to fill. Run history cards are named by the case’s values (or the time).
Run — “Run” under “This case”. If the frame or split is missing it is decided on the spot and written to the workflow. Searches over the same scope are grouped so the material is read once (gathering — a large scope uses the search index to pick candidate pieces, and a field with no candidates is “not found” without AI); units · gathering · web searches that do not wait on each other run together — a unit waits only for its own material and its order (earlier units), longest chains first. The app grows and shrinks how many AI calls run at once by watching the account rate limit (shared across runs), and a rerun over the same material takes the gathered answers from memory instead of calling AI again. Each run leaves the result document · the log of what was put in (주입.xlsx) · a summary · the request · progress in a job-numbered folder under Workflows in Files (workflow/JOB-…/), and stays in this workflow’s run history.
Run details — click a card under “Run history”: the canvas area shows that run’s lineage view, and a “Run result” card appears below the history. The list icon at the right of the card header is “Show files · Close files” (opens or closes that run’s folder in the files drawer — same as “Show this conversation’s files” in the chat header; with the drawer open, picking another run follows to its folder). While it runs, the steps running at that moment show at the top of the card. The card is split by labels — result document · found at (a table — unit · source shortcut (a web address opens a browser tab) · pin) · run files (a numbered list: 1 summary · 2 injection log · 3 request) · report (the small button is “Create report” · “Recreate report”, paused runs too — it captures the lineage view and the AI writes steps · units · gathering · speed · errors · causes · a verdict (feature · build · data · external), fixes, and a result evaluation (usable · needs fixes · redo — fill · grounding (where values came from) · layout (whether the form’s labels survived; pages that differ from the form are rendered and checked for overflow · overlap) · task conditions) to 보고서.md in the run folder). Clicking a file name in the card opens only the preview window; the files drawer stays as it is (use the header icon for the drawer). A running or paused run gets buttons at the bottom (running = “Stop”, paused = “Try again” · “Stop”).
Pin as search — in the “Found at” table of run details, “Pin” next to a place a unit actually found data (it then shows “Pinned”) makes it that unit’s search target — if a search with the same method and target exists it is wired to the unit; otherwise the empty-target search wired to that unit takes it; otherwise a new search node is added. The next run looks there first.
Try again — if a required field cannot be filled it leaves the summary and stops. Add the data and press “Try again”; workers look again only for the functions not filled.
Re-inject edited values — edit a value in the run folder’s 주입.xlsx, then right-click the file → “Re-inject edited values”; only those fields change in the result.

Block graph workflows (made earlier)

Workflows wired from nodes (blocks) earlier still open and run as before. This kind can no longer be created on screen; the list holds only ones made earlier and ones brought in with “Get package”. Place nodes on the canvas and wire outputs to inputs — the picture runs as drawn and always ends in one document.

Layout — the header holds only the name and three tab groups (Overview | AI · Nodes · Details | Input · Run). “Overview” is one page: edit the name and purpose, current state (nodes · ending), the check (errors · warnings one per line — click a line with a node to open that node’s details on the canvas), recent runs, publish to the team market · delete. Check errors show as a count on the “Overview” tab.
Start · Result — a block graph workflow always has a “Start” and a “Result” node (they can’t be deleted). Click Start to list the inputs a person gives when a run starts; connect the finished document to “Result”.
Filling an uploaded document — name an hwp · hwpx · docx · xlsx · pptx document (path or file name) to the AI and, if it is not a template yet, the app first registers it as one (fields and repeating rows) so the builder fills that document — the result keeps its format. The AI’s reply says which template it registered.
Materials for Generate text — in Details, mark each material as required or not. A missing required material skips the node; a missing optional one still writes and leaves that spot as “needs input”. With no materials at all it does not write.
It always ends in a document. Two ways: fill a fixed template file (pick it in “Make document”), or let AI create a template (“Create template”), fill it, then “AI review”. If some fields stay empty, the run writes a summary md saying what is missing and why, then stops.
Build — drag tiles from the “Nodes” panel onto the canvas, or click one to place it in the middle of the view. Groups: Get data (Read file · Web search · Ask a teammate · User input) · AI (Extract info · Generate text · Classify · Create template · AI review) · Process data (Process data · Repeat) · Flow (Approval) · Output (Make document). “AI” is a chat — describe the job and AI builds it and places it on the canvas; say what to change (“also take a contact name as input”) and it edits the current graph, keeping its nodes. Undo the last turn from the chat header.
Details — click a node to edit it. Process data’s filter conditions · aggregates · columns (with renames) are row fields; Repeat picks the node to run for each row and which column feeds each of its inputs.
Wire — drag a node’s right side (output) onto another node’s left side (input). Dot color = value type (text · number · date · choice · table · yes/no · file). Mismatched types don’t connect (number · date → text is fine). Values received from a teammate (sealed) only connect into “Make document”.
Fallbacks — wire several links into one field and they are tried in order (e.g. file → web → person). Once an earlier path finds a value, later paths don’t run.
Run — enter the input values in the “Run” panel and run. Every run leaves the inputs · answers · result document · summary under the Files tab “Workflows”, in a folder named by its job number (workflow/JOB-…/). Results containing teammate values are hidden from AI.
Runs — one line per run (job number · state · time), scrolling past 3–4 cards. Filter by state with the pills above (All · In progress · Done · Failed · cancelled); past 12 runs, “Show more”.
Run details — click a card and below it shows start · duration (or the current step while running), progress (finished nodes / node count bar), stopped nodes (failed · needs an answer · cut off — click to open that node’s details on the canvas), signals (as counted by Watch), error, files (summary · result · input · report — click to preview in the files drawer without leaving the workflow; the small button on the report line creates or recreates it), and the input values actually used. Buttons: “Stop” (while running) · “Run again” (same input values) · “Fill values” (put those values into the input fields to edit and run) · “Monitor” (this run in Monitoring) · “Template” · “Continue”. The “Result” node also links that run’s result file.
Continue — for a stopped or failed run, “Continue” in its details starts a new run from that run folder’s progress (진행.json) — finished nodes are reused, not run again.
Fix from report — on a finished run that has a report, “Fix from report” in its details lets the AI builder read the report’s causes and fixes plus the summary and propose a fixed graph (nodes kept). The canvas changes only when you press “Apply fix”; run again once it is saved.
Run report — the create button on the report line of the run details (recreate once one exists) captures that run’s canvas and Watch pictures (the view switches briefly) and AI writes the workflow state · each node’s run state · errors · causes · a summary (feature problem · builder problem · external problem · other error) and what to fix into 보고서.md in the run folder. “Suggest a fix” reads this report too.
Stopped runs — answer “User input” · “Approval” in the Run panel and the run continues. If it stopped on missing fields, “Suggest a fix” asks the builder for a fixed graph, then “Retry” — finished nodes do not run again. A run cut off when the app closed shows the node as “Cut off”; “Retry” continues from that step.
Watch — click a run card in the “Run” tab and the main area shows that run as a lineage graph — what it actually read and wrote, including anything undeclared (the same picture as Monitoring “Flow”). Click the card again to return to the canvas.
Template — if you like a template AI created, “Template” in that run’s details saves it as a template under notes/; later runs fill it.
Team market — in a team project, “Publish to team market” in Overview uploads the graph plus its template files as one package; “Get package” in the list installs one. No values are included. New-kind workflows can’t be published.