# Build agent logic on a canvas, not in one giant prompt.

A drag-and-drop canvas of prompts, branches, tool calls, and transfers that runs as the brain behind your voice and chat agents. Test the draft in the editor, then publish an immutable version to go live.

## What it does

### Eleven node types on one canvas

Conversation prompts, tool calls, logic branches, channel splits, data extraction, variable assignment, raw HTTP requests, live-call transfer, and end nodes, plus frames and sticky notes to keep large graphs readable. Right-click anywhere on the canvas to place one.

- Nine executable node types plus two canvas annotations
- Right-click the canvas to add a node in place
- Minimap and fit-view controls for large graphs

### Prompts scoped to the node, not the agent

Each conversation node carries its own instruction, optional few-shot example pairs, and an optional model or temperature override. A global prompt sets shared behavior, and greetings resolve per channel and direction, so an outbound call can open differently than an inbound chat.

- Few-shot example pairs attach to individual nodes
- Model and temperature overrides on conversation and tool nodes
- Greetings resolve per channel and direction

### Test the draft against the real engine

The test drawer chats against your working draft using the same engine, tools, and models that serve production. Every reply expands to show which node produced it, the model, tokens in and out, latency, cost, and any tool calls with their arguments and results.

- Draft runs never touch the published version
- Per-reply node, model, token, latency, and cost meta
- Tool calls expand to arguments and results

### Versioning that works like code

Edits autosave to a draft while live traffic keeps executing the last published version. Publishing snapshots an immutable numbered version. Branches give you a Main plus long-lived drafts; merging copies a branch into Main and republishes without ever changing the flow id.

- After the first publish, live runs never execute the open draft
- Publish writes an immutable numbered snapshot
- Merging a branch never changes the flow id
- Merged branches are kept for continued edits

### Human transfer as a graph node

The transfer node hands a live call to a person: cold or warm mode, ordered target hunting with retries and ring timeouts, answering-machine detection, hold music, and briefing or intro lines that can be written by the LLM from the call transcript. Every outcome is a wireable branch.

- Warm mode detects voicemail on the agent leg before bridging
- Connected, voicemail, no-answer, and failed each get a branch
- Unanswered transfers can resume the AI instead of hanging up

### One flow behind every channel

A published flow answers phone calls through a per-flow OpenAI-compatible endpoint and chat through the channel gateway. Session state is keyed per call or per conversation. A channel node splits voice and chat paths when they should differ; otherwise one graph serves both.

- Voice sessions keyed per call, chat per conversation
- Channel node carries no settings; it routes on the live channel
- Transfer nodes degrade gracefully on chat channels

## Under the hood

- **NODES:** 11 node types: 9 executable plus frame and sticky-note canvas annotations
- **VERSIONS:** Publish writes an immutable numbered snapshot; after first publish, live runs load only the latest published version
- **BRANCHES:** Main plus long-lived draft branches; merge copies into Main and republishes under the same flow id
- **CHANNELS:** Voice runs through a per-flow OpenAI-compatible endpoint; chat runs through the channel gateway
- **TRANSFERS:** Cold or warm handoff with target hunting, voicemail detection, hold music, and per-outcome branches
- **MODELS:** Default and fallback model per flow, overridable on conversation and tool nodes; platform keys or bring your own
- **VARIABLES:** Contact, business, and date-time variables built in; a webhook can inject more at session start

## FAQ

**How does a flow run a live phone call?**

Each flow exposes an OpenAI-compatible chat-completions endpoint. Telephony posts the transcript once per turn; the engine walks the graph, runs tools, and returns the line to speak. State is keyed to the call, so retries and barge-ins never re-run side effects; a failed model retries on the fallback, not as a spoken error.

**What happens to live traffic while I edit?**

Nothing. Edits autosave to a working draft while calls and chats keep executing the last published version. When you publish, the draft is frozen as a new numbered version and traffic moves to it. Branches let you stage larger rewrites and merge them back when ready.

**Can a flow call my own APIs?**

Yes. API Call nodes send HTTP requests with configurable method, headers, and body, and store the response in a variable for later nodes. Tool nodes run registered workspace tools, calendar booking is native, and async edges fire steps in the background without delaying the reply.

**What are the requirements and limits?**

Once published, calls and chats execute the latest published version, not your open draft. Transfer nodes act on live voice calls; on chat channels they route down their failure branch instead. Outbound HTTP from nodes passes an egress guard that blocks internal addresses.

**What does it cost to run flows?**

Flows are included in the platform. Usage is billed per channel: voice at $0.07 per minute and messages at $0.02 each. Signup is free pay-as-you-go. If you bring your own LLM key, model usage carries no LLM charge.

---
Source: https://www.assistable.ai/platform/flow-builder