Workflows: Agents Wired Together

A single AI agent is useful. Given a clear role, good context, and a specific task, it can produce output that would have taken a person thirty minutes to draft. But a single agent has a natural limit: it can only do one thing well. Ask it to research, then write, then edit, then format — all in one go — and quality degrades. The instructions conflict. The context bloats. The output becomes unreliable.

This is the same problem that specialisation solves in human teams. A journalist does not simultaneously research, draft, sub-edit, and fact-check. Those are different disciplines, done by different people, in sequence. Each hand-off sharpens the work.

Agent workflows apply the same logic. Instead of one overloaded agent, you build a chain of specialists — each with a precise role, working on the output of the one before it. The result is a pipeline: raw material goes in one end, finished output comes out the other, and quality compounds at every step.

An agent workflow — sometimes called an orchestration or a pipeline — is an ordered sequence of AI agents where each agent's output becomes the next agent's input. The chain begins with a piece of text: raw notes, pasted data, a brief, a document. It ends with finished, usable output. Everything in between is transformation.

Each agent in the chain has a single, well-defined job. It receives the previous agent's output as its input, processes it through its own system prompt, and produces something more refined, more structured, or more targeted. The more specialist each agent, the better the chain performs as a whole.

The number of agents in a chain depends on the complexity of the task. A simple two-agent chain — draft, then polish — is enough for many use cases. More complex workflows might use four or five agents, each adding a distinct layer: structuring, writing, checking, summarising, formatting. The right chain is the shortest one that reliably produces the output you need.

Crucially, each agent only sees its immediate input — the output of the previous step. It does not have access to the original source material or to the outputs of steps further back in the chain unless those have been passed forward. This keeps each agent's context clean and focused, which is precisely why quality improves at each step rather than degrading.

Understanding what happens when a workflow executes helps in designing reliable chains and diagnosing problems when they occur. The execution is sequential: each step must complete before the next begins. There is no parallelism — one agent works at a time, in order.

1. 1Trigger: Something starts the workflow — a user clicking "Run", a scheduled time, or an external event arriving via a webhook. The trigger provides the initial input text.
2. 2Initialise: A workflow run record is created. One step record is created for each agent in the chain, all set to "pending." This gives a full audit trail before execution begins.
3. 3Step 1 runs: The first agent receives the initial input. Its system prompt defines its role. The LLM processes both and returns output. The step is marked "completed" and its output is stored.
4. 4Handoff: The first agent's output becomes the second agent's input. This handoff is automatic — the system passes it forward without any human involvement.
5. 5Steps 2–N run: Each subsequent agent receives the previous agent's output as its input, processes it, and passes its own output forward. This continues until the final agent completes.
6. 6Completion: The final agent's output is the workflow's result. The run is marked "completed." The output is stored, displayed, and optionally sent to an email address, external system, or downstream process.

Full automation is not always the right design. Some tasks require a human judgement call before the workflow continues. A draft proposal needs a human to review it before it goes to a client. A flagged complaint might need a manager's approval before a response is sent. A piece of generated content might need a tone check before it is published.

Human-in-the-loop (HITL) is the design pattern that handles this. An agent in the chain is configured to pause after completing its step and request human input before the workflow continues. The workflow does not fail — it waits. The human is notified, reviews the output, provides any refinement or instruction, and approves the workflow to proceed. The next agent then runs with both the previous output and the human's input in its context.

HITL is particularly valuable in the early stages of deploying a new workflow. Running with human review for the first few weeks builds confidence in the chain's quality. As reliability is established, the pause point can be moved later in the chain or removed entirely — leaving the human to only review the final output, rather than intermediate steps. Automation earns its place incrementally, with human oversight reducing as trust increases.

Building a reliable workflow is a technical act. Using one should not be. Once a workflow chain is stable and produces consistent results, it can be packaged as an App — a clean, form-based interface that presents only what the end user needs to provide, and returns only the output they need to see. The agents, the prompts, and the chain architecture become invisible.

An App wraps a workflow in three things: a structured input form that collects the specific information the workflow needs, a progress indicator that confirms processing is underway without showing the technical detail, and a formatted output view that presents the final result clearly. A care home manager does not need to know that three agents are involved in producing a family update letter. They fill in a short form — resident name, the week's notes — and receive a polished letter in seconds.

Apps shift AI from a tool that technical users build and run to a service that anyone in the organisation can use. They also make workflows shareable: the person who understands the agents and prompts builds and maintains the App; the people who benefit from it use it without needing to understand how it works. This is the model by which AI capability distributes across a team without requiring everyone to become a prompt engineer.

Agent workflows are not sector-specific. Any task that can be described as a sequence of transformation steps — raw input becomes refined output through a series of expert operations — is a candidate for a workflow chain. The following examples illustrate the pattern across a range of industries, all of which we have mapped in Kindling.

The pattern across every sector is the same: there is a piece of repetitive, expert writing work that follows a consistent structure. It requires skill to do well, but the skill is in the rules — which are, with care, encodable into a well-crafted agent chain.

A workflow that runs reliably in production is designed differently from one built to demonstrate a concept. The following principles, drawn from building workflows across every major sector, are the difference between a chain that teams trust and one that quietly stops being used.

A single AI agent saves time. A chain of agents handles a whole task. A chain connected to an event trigger handles a whole task the moment it needs to be done — without anyone having to remember to start it.

This is the progression that distinguishes organisations using AI tactically from those using it structurally. Tactical AI sits alongside work. Structural AI is woven into the flow of operations: responding when emails arrive, producing briefings before meetings start, processing documents the moment they are uploaded, and distributing finished outputs to the people who need them.

The technology is ready. The workflows are buildable today. The constraint is almost always design — identifying the right tasks, building the right chains, connecting the right triggers, and giving the right people the right Apps. That is the work, and it compounds. Each workflow deployed saves time on every future instance of that task, indefinitely.