Services Case Studies Impact About Insights Contact
Get in Touch
Insights Enterprise AI Architecture
Series · Part 2 of 3 Published · July 2026 8 min read

5 Workflow Patterns That Solve 95% of Enterprise AI Problems And why most teams reach past them for something they do not need

The production-proven patterns - prompt chains, routing, parallelisation, orchestrator-subagent, and evaluator loops. They are not exciting. They are deterministic enough to audit, cheap enough to scale, and simple enough to debug. They are what ships.

Part 2 of The Enterprise AI Architecture Series
Kamlesh Kshirsagar
Kamlesh Kshirsagar
Founder & Chief AI Officer, ProDataAI

In Part 1 we argued that the workflow-versus-agent choice is not binary. It is a dial. This piece is about what actually lives at positions two and three on that dial - the workflow patterns that quietly solve most enterprise AI problems while everyone else is trying to build agents.

Core Thesis

There are five patterns. They are not exciting. They are what ships. The gap between "one LLM call" and "a full agent" is where 95% of production value lives - and it is the step most enterprise AI conversations skip straight past.

The pattern gap in most enterprise AI conversations

When a boardroom discusses AI architecture, the conversation tends to jump from "we need an agent" to "which framework should we use." The step in the middle - what pattern actually fits this problem - is rarely named. Which means most enterprise teams end up building either a single-LLM-call chatbot or a full agent, with nothing in between.

That gap is where 95% of production value actually lives.

Diagram: a spectrum from one LLM call on the left to a full agent on the right, with the five workflow patterns - prompt chaining, routing, parallelisation, orchestrator-subagent, evaluator loops - occupying the highlighted middle band labelled 95% of production value

The five patterns sit between the single call and the autonomous agent. Every one of them is a workflow: the developer controls the route, the model does the reasoning at each step.

Anthropic's engineering team catalogued five compositional patterns in Building Effective Agents. All five are workflows in the strict sense - the developer controls the route, the model does the reasoning at each step. All five are deterministic enough to audit, cheap enough to scale, and simple enough to debug. And all five have been shipping in production for two years while the industry has been distracted by autonomous agents.

This piece describes each in business terms, when to use it, and what it costs when you use it wrong.

01

Prompt chaining: the assembly line

Wins: sequential, one artefactCosts: latency

Prompt chaining is a sequence of LLM calls where each step processes the output of the previous one. One call extracts, the next classifies, the next summarises, the last formats. Each station does one thing well.

The business analogy is the assembly line. Each station performs a specific, repeatable task. The output of one is the input of the next. Nothing is left to interpretation. If the process breaks, you know exactly which station broke it.

Diagram: prompt chaining shown as an assembly line - input flows through four sequential LLM calls (extract, classify, summarise, format) with a gate between each, then to output

Where it wins. Any process with predictable, sequential steps and a clear artefact at the end. Regulatory filings. Onboarding document generation. Multi-stage document translation. BaFin compliance summaries. In our client work, at least 40% of what enterprises call "AI use cases" collapse to this pattern.

Where it costs you. Latency. A five-step chain runs five times slower than a single call. If your use case is user-facing and sub-second matters, chain fewer steps.

Prompt chaining is not a placeholder architecture. It is the pattern most enterprise AI teams should default to and few do.

02

Routing: the triage desk

Wins: broad input, specialised handlingCosts: routing errors compound

A routing workflow sends the input to one of several specialised follow-up paths. A first LLM call reads the request, classifies it, and dispatches it to the right handler. The handler can be another LLM call with a specialised prompt, a different model, or a workflow of its own.

The business analogy is the triage desk in a hospital emergency department. One person makes a fast assessment and sends each patient to the right team. General complaints go to one path. Urgent trauma goes to another. Fraud goes to a third. The triage nurse does not treat the patient. The triage nurse decides where the patient goes.

Diagram: routing shown as a triage desk - input goes to a router LLM call that classifies the request, then dispatches to one of three specialised handlers before converging on the output

Where it wins. Customer support inboxes. Multilingual document intake in a DACH enterprise handling German, French, Italian, English and Polish in one queue. Insurance claims that split into fifteen sub-flows depending on policy type. Anywhere the input distribution is broad but each subclass has a well-defined response.

Where it costs you. Routing errors compound. A misrouted request costs you not just the wrong response but the time it takes to detect and re-route. Invest in the classifier prompt. Log the routing decisions. Treat the router as the most critical LLM call in the workflow, not the least.

The router is not a preprocessing step. It is the workflow. Everything else is what happens once the routing decision is made.

03

Parallelisation: the pit crew

Wins: independent subtasksCosts: token spend, coordination

A parallelisation workflow runs multiple LLM calls simultaneously and aggregates the results. It comes in two shapes. Sectioning splits one task into independent subtasks that run in parallel and combine at the end. Voting runs the same task multiple times with different prompts or models and takes the majority answer or the most confident one.

The business analogy is the Formula 1 pit crew. Four wheels, one team, four seconds. No worker waits for another. The result is a car back on the track faster than any sequential process could achieve.

Diagram: parallelisation shown as a pit crew - input splits into three subtasks running in parallel, which then feed an aggregation step that combines or votes before producing the output

Where it wins. Multi-document review - each contract, each supplier form, each medical record in parallel. Vendor comparison across dimensions. Code review where different prompts check for different vulnerabilities. Content moderation where three checks run simultaneously - sentiment, factual accuracy, brand safety. Anywhere the aggregate answer is stronger than any single answer.

Where it costs you. Coordination overhead and token spend. If your subtasks are not truly independent, parallel execution just multiplies the failure surface without gaining speed. And voting workflows can be expensive - three runs of the same task cost three times as much as one.

Parallelisation is not always faster. It is faster only when the parts are actually parallel.

04

Orchestrator-subagent: the project manager

Wins: complex structured deliverablesCosts: token consumption

An orchestrator-subagent workflow uses a central LLM to break a complex task into subtasks, delegate each to a specialised LLM, and synthesise the results. The orchestrator does not do the work. The orchestrator decides what work needs doing.

The business analogy is a project manager. They receive a brief - "produce a market-entry report for a new geography." They do not write the report. They decompose it into research, financial analysis, competitor mapping, and regulatory review. They assign each to the right specialist. They synthesise the outputs into a single deliverable. The specialists never talk to each other. They talk to the project manager.

Diagram: orchestrator-subagent shown as a project manager - a brief goes to an orchestrator LLM call that delegates to four specialised subagents (research, financial analysis, competitor mapping, regulatory review) whose outputs return to a synthesis step

Where it wins. Research synthesis across sources. Long-form deliverables that require multiple perspectives. RFP responses. Due diligence reports. Anywhere the deliverable is too complex for a single prompt but too structured for a full agent.

Where it costs you. Token consumption. The orchestrator holds the full context of every subagent's output. That context grows fast. Budget for it.

This pattern is often what teams build when they think they are building an agent. The difference is that here, the developer controls the decomposition. In an agent, the LLM does. Say what you actually built.

05

Evaluator loops: the writer and the editor

Wins: quality over speedCosts: iteration count

An evaluator loop runs one LLM to produce a response and a second LLM to critique it. If the critique passes, the response is returned. If not, the first LLM revises based on the critique. The loop continues until quality criteria are met or a maximum iteration count is reached.

The business analogy is the writer and the editor. The writer drafts. The editor reads with fresh eyes and marks up what needs work. The writer revises. The editor reads again. The final draft is not the writer's alone. It is the product of two minds correcting each other.

Diagram: evaluator loop shown as writer and editor - a generator LLM drafts, an evaluator LLM critiques, and failed critiques feed back to the generator for revision until the output passes

Where it wins. Regulated content generation where accuracy matters more than speed. Literary or technical translation where nuance requires iteration. Complex code generation with test-driven validation. Long-form drafting where a single pass rarely produces publication-ready output. Any workflow subject to EU AI Act Article 14 human-oversight expectations, where the evaluator can be a first-line check before the human reviewer.

Where it costs you. Iteration count. Each loop is another two LLM calls. Set a hard cap. Track the average iterations per output in production. If your loops routinely max out, either the evaluator criteria are too strict or the generator model is not strong enough for the task.

The evaluator is not overhead. It is the mechanism by which quality becomes measurable.

How to choose between them

Which pattern fits your problem is usually clear once you write down the shape of the input and the shape of the output.

PatternShape of the problemBusiness analogyTypical enterprise use
Prompt chainingSequential steps, one clear artefactAssembly lineRegulatory filings, compliance summaries
RoutingBroad input, specialised handlingTriage deskCustomer support, multilingual intake
ParallelisationIndependent subtasks or repeated checksPit crewDocument review, content moderation
Orchestrator-subagentComplex deliverable, structured decompositionProject managerResearch reports, RFPs, due diligence
Evaluator loopsQuality matters more than speedWriter and editorRegulated content, translation, code

Most real enterprise systems combine two or three of these. A supplier-onboarding workflow uses routing at the intake and prompt chaining inside each route. A regulatory reporting system uses orchestrator-subagent for the section-by-section drafting and evaluator loops for final review. The patterns are not exclusive. They compose.

Diagram: a supplier-onboarding pipeline composing three patterns - routing on language and document type, then a prompt chain to extract, validate and map to schema, then an evaluator loop for the policy check with a human approval branch

The supplier-onboarding system from Part 1, re-read as patterns. Three of the five, one human checkpoint, no agent anywhere - and none of it needed one.

Where teams go wrong

Three failure modes we see repeatedly in enterprise deployments.

Building an agent when a chain would ship

The most common failure. A team decides they need "an agent" for a task that is genuinely sequential and reasonably predictable. They spend six months building autonomy features they never needed and cannot govern. A prompt chain would have shipped in six weeks with better reliability and one-tenth the cost.

Skipping routing because it feels too simple

Enterprise teams often want the single-LLM-call solution because it is clean. But when the input distribution is broad - multiple languages, multiple document types, multiple regulatory contexts - a single prompt trying to handle everything is what actually fails in production. Routing is not a compromise. It is the pattern.

Treating orchestrator-subagent as an agent

Because the orchestrator makes decisions about task decomposition, teams sometimes describe it to leadership as "our agent." This is a labelling error with real consequences - it changes the governance conversation, the audit conversation, and the risk conversation. If the developer wrote the decomposition logic, it is a workflow. Say so.

Three questions to ask your AI team this week

  1. For each of our current AI projects, which of the five patterns fits? If the answer is "none," we are probably over-reaching for an agent.
  2. Where are we running LLM calls sequentially that could run in parallel? What would it cost - in tokens and in latency - to change?
  3. Are we using evaluator loops in production, or just at pilot? If just at pilot, why not in production?

Key takeaways

Five patterns solve most of what enterprise AI is asked to do. Chains, routing, parallelisation, orchestrator-subagent, evaluator loops.

The gap between "one LLM call" and "a full agent" is where 95% of production value lives.

Patterns compose. Most real enterprise systems use two or three together.

The most common failure is not picking the wrong pattern. It is jumping past patterns to agents.

If a developer writes the decomposition logic, it is a workflow. If the LLM writes it, it is an agent. Say what you actually built.

Working through this in your organisation? We help European enterprises pick and combine the right patterns for their problem.

Book a 30-min call →

References

  1. Schluntz, E. & Zhang, B. - Building Effective Agents. Anthropic (2024).
The Enterprise AI Architecture Series
Part 1
AI Workflows vs AI Agents: Where to Set the Dial
The CLEAR test, agent washing, the cost reframe, and why most enterprises set the dial too far right. · 7 min read
Part 2 · You are here
5 Workflow Patterns That Solve 95% of Enterprise AI Problems
Prompt chains, routing, parallelisation, orchestrator-subagent, and evaluator loops - and how they compose. · 8 min read
Part 3 · Coming soon
When You Genuinely Need an Agent: A Production Readiness Checklist
The 12 questions to answer before granting autonomous decision-making to any system.

Not sure which pattern fits your use case?

We help European enterprises pick and combine the right patterns for their problem - designing workflows that ship in production rather than agents that stall at pilot. A 30-minute conversation costs nothing. If we are not the right fit, we will say so.