Agent nodes
Nodes that run an agent to do real work on the canvas — long-running, producing finished deliverables that are checked before they're surfaced.
Most nodes do one thing. An agent node does the whole job: it runs an agent through a multi-step loop — researching, reasoning, and drafting with the same tool set Alto uses — and produces a finished deliverable right on the canvas.
It's the difference between "fetch this" and "go away, work through this, and come back with the result."
Long-running by design
An agent node doesn't block while it works. When you run it, the work happens as a background job — the canvas stays responsive, and the node reports progress as it goes. Longer jobs unfold over several internal steps: the agent can search your knowledge, search the web, read other nodes on the canvas, and think between steps before it commits to an output.
Because it runs in the background, you can:
- Track its status as it moves from queued to running to done.
- Stop it mid-run if it's heading the wrong way, rather than waiting it out.
- Let it feed downstream work — a finished agent node's output flows to whatever is connected after it, so one node's result becomes another's input.
Each run works to a time budget and a step limit, then delivers what it has — so a node always resolves to a result rather than running indefinitely. For bigger bodies of work that span more than one run, see how agents pick work up across passes.
What it can produce
An agent node produces a real deliverable, not just text — and the kind of deliverable depends on the node you choose:
- Documents — written reports, briefs, and notes.
- Presentations — slide decks, including freeform (HTML) decks for pixel-level layouts.
- Designed documents — paginated, brand-themed long-form pieces.
- Frameworks — structured canvases like a Business Model Canvas.
- Spreadsheets, HTML, and images — tabular data, self-contained web pages, and generated visuals.
Each is a first-class output you can open, edit, and export. See the node catalog for the full list.
The verification pass
Before an agent node's output is surfaced, it's checked — so what lands on the canvas is well-formed and traceable, not a raw draft:
- Output validation. The deliverable is submitted through a step that validates and normalizes its structure. If something's malformed, the agent is told and fixes it before the result is saved.
- A completeness check. A too-thin result is treated as insufficient and sent back for another pass rather than shipped as-is.
- Citation integrity. When the output cites sources, every citation must resolve to a real source the agent actually retrieved during the run — no citation without a source behind it. This is what makes the deliverable auditable.
These checks guarantee the output is structurally sound and that every citation traces to a source the agent actually retrieved during the run — so what lands on the canvas is well-formed and auditable.