Side-by-side comparison
Each pattern has a sweet spot — the failure mode is using the wrong one for the workflow.
- AI agent — high autonomy, dynamic plan, LLM reasoning + tools, best for variable knowledge work.
- AI copilot — human-in-the-loop, single-app suggestion, best for productivity inside an existing UI.
- RPA — zero autonomy, brittle to UI change, best for legacy systems with no APIs.
- Workflow automation — deterministic DAGs, no reasoning, best for stable cross-system pipelines.
When to combine them
Modern enterprise stacks use all four. An agent reasons about what should happen, calls a workflow automation step to fan out to systems, and falls back to RPA only when an API does not exist. The copilot surfaces the agent's actions to the user for approval.
Choosing by the shape of the work, not the label
The four categories are not competitors so much as answers to different questions. Ask what varies in the work: if the steps vary, you need an agent; if only the content varies, workflow automation with a model step is enough; if nothing varies but the interface is unautomatable, RPA fits; if a person stays in the loop for every item anyway, a copilot is the cheaper help.
- Stable steps, stable systems, high volume → workflow automation or integration.
- Stable steps, no API available → RPA, accepting its brittleness to UI change.
- Variable steps, context assembly, decisions across systems → agent.
- Human does the work and wants acceleration → copilot.
Why the wrong choice is expensive in both directions
Choosing an agent for deterministic work buys you nondeterminism, evaluation overhead, and run cost in exchange for nothing — a scheduled job would have been correct every time. Choosing automation for genuinely variable work produces the opposite failure: an ever-growing rules thicket, with exception handling that eventually costs more than the work it replaced.
The honest test is to look at a sample of real cases and count how many followed the documented happy path. A high exception rate is the signal for agentic judgment; a low one is the signal to just build the integration.
Combining them is usually the right answer
Mature implementations rarely pick one. An agent decides and assembles; deterministic automation executes the steps that must never vary; RPA covers the one legacy screen with no API; a copilot surface lets the reviewer inspect and override. Governance then applies at the boundary — the agent may recommend anything, but only approved, permissioned actions execute.