At a glance
- Does
- Opens the window and stops — opening never runs the rest of the flow
- Ports
- Input opens it, Call fires per message, Response is where the answer comes back
- Emits
- message, history, historyText, chatID, timestamp, images
Set it up
Wire any trigger into Input — a Keyboard Shortcut is the classic — and firing it opens the window. From there every message is its own run, starting at this node's Call outlet. Wire the answer back into the node's own Response inlet: a drawn loop, allowed here and nowhere else.
One lap per message. Call goes out with what was typed, whatever you built behind it does the answering, and the payload that reaches Response is rendered through Response shows and appended as the reply. A Response wire that is never reached simply leaves the window with nothing to say.
The "Open Chat…" button in this node's inspector and the same item in the flow's menu on Home both open the window directly, with no trigger involved. Nothing opens it at app launch.
Configure
| Field | Default | What it does |
|---|---|---|
| Window Title | the flow's name | Shown in the window's title area and on the empty state. |
| Composer Placeholder | — | The grey words in the empty composer. |
| History turns sent to the flow | 20 | How many prior turns ride along on Call as {{history}} and {{historyText}}. 0 sends none. |
| Conversation | Kept across openings | Kept survives closing the window and relaunching the app. Fresh each time it opens clears the transcript from the window and from disk whenever the window comes on screen — never mid-answer, and never on a window already up. |
| Response shows | {{result}} | What the window renders as the reply. The default needs no configuration behind an AI Prompt or an Agent. |
Output
Every key below is in the seed a message run is entered with, on the Call outlet.
| Key | Type | Value |
|---|---|---|
message | String | What the person just typed |
history | Array | The recent turns as real objects — {{history.0.role}}, {{history.0.text}}, {{history.0.timestamp}}; user and assistant only, oldest first |
historyText | String | The same conversation as plain text, one line per turn — paste it into a prompt for context |
chatID | String | Which chat window this run came from |
timestamp | String | ISO 8601 time the message was sent |
images | Array | The images pasted with this message, as real file references. Always present, empty when there are none |
Tools
The chat window is the harness, so this node is where you choose what the conversation can reach. Its inspector has the Agent's own Tools list, and whatever is switched on is lent to the models behind Call for each message. A new Chat node is born with Web Search and Web Fetch on, so a freshly dragged chat can answer about this morning instead of saying it cannot browse. A Chat node built before this existed lends nothing until you switch something on.
Code tools — Edit File, Search Code, Repo Map, Git, Open PR — are greyed out here: they need a File Access Scope folder, which only the Agent has. For real code powers, put an Agent behind Call and enable them there. Turning on a writing tool marks the Chat node destructive on the canvas, and rightly so: a chat runs whenever somebody types.
Reading a reply
- Three actions under every answer — Copy, Open run, Regenerate — at full ink on the newest reply and on whichever one you are hovering. Right-click adds Copy as Plain Text. Regenerate re-asks the message above the reply; it is greyed while a lap is in flight, because a second send would interrupt and re-ask instead.
- A failed lap gets a card instead, red-edged, with the reason and a single Retry button.
- Fenced code blocks are syntax highlighted and headed by the tag the model wrote (
Codewhen it wrote none), with a fold chevron and a Copy button. Blocks arrive unfolded; folding collapses the body to a "60 lines" summary. Copy hands over the block exactly as it stands — no fence, no re-indentation, nothing trimmed — and confirms with a green checkmark for a moment. - Markdown tables render as a real grid inside a horizontal scroller capped at the reply's reading measure, so a wide table scrolls inside the reply rather than pushing the window out past it.
Example: a support-triage assistant
Every message runs an AI Prompt with the conversation folded in, and its result wires straight back into Response.
Give the prompt Conversation so far: {{historyText}} then User: {{message}}, and leave Response shows at {{result}}.
Paste this into the Flow Builder to get the same flow:
Build a chat window opened by a keyboard shortcut, where each message goes to an AI Prompt with the recent history for context and the answer comes back into the chat.
Good to know
A second message interrupts the lap in flight. The run is cancelled and a new one starts immediately, asking every message sent since the last answer joined into one {{message}}. Those messages are the question, not the context, so they are not repeated in {{history}}. Stop is different: it abandons the question and leaves a "Stopped before replying" line.
{{result}} renders an object as JSON. An AI step answering through an Output Schema hands back an object — point Response shows at the field you mean, {{result.reply}}, or leave the answering step without a schema.
Paste images straight into the composer — up to 8 per message. An AI Prompt with a blank Image field sends them to the model with nothing to wire. An Agent cannot see pictures and says so in the run log.
Each chat keeps its most recent 500 turns, pruned automatically. Each message is its own row in the flow's run history, tagged with a Chat chip.
The model pill in the header edits the flow. It lists the AI and Agent nodes behind Call, and picking a provider and model writes them onto that node exactly as the inspector would.