When should I use a single-step agent workflow instead of the canvas editor?

Harriet workflows can be built in two main ways: a simplified workflow built around one configurable agent step, or Advanced mode (canvas editor), where you arrange multiple steps on a canvas. Both use the same configurable agent technology—the difference is how much structure you wrap around it.

For many HR processes, starting with a single-step agent workflow is the better default: you describe the outcome in plain language, assign skills, and iterate until behavior is right—without learning canvas concepts before you need them.

When a single-step agent workflow is enough

Use the simplified path when the whole process fits one agent that can:

• Follow clear instructions (Goal, How, When to stop, On error).
• Use the skills you assign (HRIS, tickets, email, knowledge base, and so on).
• Pause for ticket replies, approvals, or scheduled waits as needed.
• Optionally delegate a bounded sub-task (for example, contacting someone outside the thread) when you configure delegatable skills.

You still choose triggers (chat, ticket, schedule, webhook, and so on)—those decide when the workflow runs; they are separate from whether you use one step or many.

This approach is usually easier to maintain: fewer nodes to reason about, fewer places for instructions to drift out of sync, and faster iteration when your policy or tooling changes.

See How does the AI agent step work in a workflow? for how individual agent steps behave.

When to open Advanced mode (canvas editor)

Open Advanced mode (canvas editor) when one agent step cannot express the process cleanly—for example:

• You want several distinct automated phases as separate steps with different skills or instructions each time (lookup → act → confirm → close).
• You need branching or routing between outcomes that should not live in a single instruction block.
• Different phases have different risk profiles (for example, separating read-only lookup from steps that send mail or write to systems).

The canvas is powerful, but each extra step is something your team must document, test, and update. Use it when that structure earns its keep—not by default.

See How do I design a complex multi-step workflow? for layering triggers, pauses, and error paths.

Delegation: powerful, but one conversation at a time

Delegation lets the main agent hand off a narrow sub-task to a sub-agent, wait until it finishes, then continue with the result. That flow is serial: the parent waits for each delegated conversation to complete before moving on.

• If you need two different people contacted independently (each with their own back-and-forth), Harriet handles them one after the other, not at the same time. Total time grows with each delegation—plan timeouts and expectations accordingly.
• If one person should answer about many items in a single thread, prefer one delegation whose instructions include the full list of items and what you need back—rather than repeating nearly identical delegations for each row unless your process truly requires it.

Sub-agents cannot delegate further, and you should always set a sub-agent timeout with a clear on error path on the main agent.

See How do complex workflows delegate tasks to other agents? for patterns and guardrails.

Limitations to keep in mind

Large numbers of entities

Agents work step by step. Processes that must touch very large lists (for example, hundreds of employees or rows in one run) can become slow, harder to follow in logs, and may run into practical limits on how much context can be carried in one execution. Often it is better to split the work—for example scheduled batches, separate tickets per batch, or breaking work across multiple runs—than to force one workflow run to process an enormous table end to end.

Parallelism

Workflow agents run serially. Delegation does not fan out to multiple sub-agents in parallel; there is no way to “run five delegated conversations at once” inside one parent agent turn.

If true parallelism or high-volume throughput is required, design for multiple workflow instances (for example separate tickets or schedules), or divide work so each run stays intentionally scoped—not one oversized single run.

Summary

Situation	Good starting point
One coherent process, plain instructions, skills + optional delegation	Single-step agent workflow
Multiple phases, branching, or strongly separated responsibilities	Advanced mode (canvas editor)
Many independent external conversations in one run	Expect sequential delegations; allow enough time and timeouts
Very large entity lists in one run	Prefer batching or splitting work rather than one giant execution