Agents inside the process: where multi-agent orchestration beats BPM, and where it doesn't

BPMN 2.0 gives a process a precise, shared notation: tasks, gateways, events and the rules between them ^[1]. That precision is exactly why banks, insurers and governments run on it. A BPMN model is reviewable by auditors, versioned and deterministic: the same input takes the same path.

The cost shows up in the exceptions. Every new document type, rule interpretation or edge case becomes a gateway or a manual work queue. Over time the queues, not the model, are where the work actually happens.

Anthropic separates two designs that are often lumped together: workflows, where LLM calls follow predefined code paths, and agents, where the model decides its own steps and tool use ^[3]. Their guidance is to start with the simplest pattern that works, prompt chaining, routing or an orchestrator with workers, and add autonomy only where it measurably helps.

Where autonomy does help is broad, open-ended work. In Anthropic's account of its research feature, a lead agent that delegated to parallel sub-agents outperformed a single agent by 90.2% on their internal research evaluation ^[2]. The same post is candid about the price: agents used about four times more tokens than chat, and multi-agent systems about fifteen times more.

• Good fit: reading and classifying documents, gathering evidence from several systems, drafting a recommendation with citations.
• Poor fit: steps a rule already decides, anything that must be byte-for-byte repeatable, and low-value tasks where token cost exceeds the labour saved.

The architecture that holds up keeps the process model as the spine. Each step that needs judgement over unstructured input becomes an agent task with a narrow job and a typed output. The orchestrator, not the agent, decides what happens next, which keeps the process auditable.

Agent steps are long-running and fail in ordinary ways: rate limits, timeouts, a tool returning garbage. Durable execution engines such as Temporal exist for exactly this: they persist workflow state, retry failed activities and resume after a crash ^[4]. Graph-based agent frameworks such as LangGraph add checkpointing and human-in-the-loop interrupts at the agent level ^[5].

Decisions that carry legal, financial or clinical weight stop at a human checkpoint with the agents' evidence attached. NIST's AI Risk Management Framework frames this as governing and managing risk across the lifecycle rather than trusting a model's output by default ^[6].

Start with one process whose exception queue is large and whose decisions are well documented. Run the agent step in shadow mode next to the current manual step and compare outputs on real cases. Promote it only when disagreement is understood, and keep the manual queue as the fallback path in the process model.

Measure the things a process owner already tracks: cycle time, the share of cases that reach the exception queue, rework, and the cost per case including model usage. If the agent step does not move those numbers, it should not ship.

Process owners stop drawing every branch and start defining outcomes, confidence thresholds and who approves what. That is a smaller change than it sounds: the people who understand the exceptions today are exactly the people who should set the rules for agents tomorrow.

Found this useful?

Share the key finding on X.