How to build an agent factory, stage by stage

Four young people at a round wooden table where pastel sticky notes form a closed circle; a woman in a yellow sweater places the last one while a colleague in mint points at another

An agent factory is not a faster version of today’s workflow but the same workflow closed into a loop, in which every stage leaves a record and people move from doing the work to three decision points: they approve the case description, confirm the checks and agree to the release.

Agents prepare everything in between. A company that moves its old workflow across one for one, with an agent where a person used to be, will get more output, not better output.

The pattern comes from software development, where it is most mature. We will show it on a process almost every trading company has: complaint handling. Why loops like this will leave IT is the subject of the piece on agent factories outside the IT department.

The old workflow in one paragraph

The classic software development lifecycle (SDLC) is a relay of people. An analyst gathers requirements, an architect designs, a developer writes, a second one reviews, a tester tests, an administrator deploys. Complaints work the same way. Customer service logs the claim, the warehouse checks the dispatch, the account manager weighs up the customer, accounts issues a credit note, someone writes back. Between every pair there is a handover: an email, a note, a chat at the coffee machine. Knowledge of why a case was settled one way and not another stays in people’s heads.

That model worked because people’s time was the most expensive resource, and handovers were the price of working together. In a factory, execution becomes the cheapest thing and human attention the most expensive. That turns the logic of the whole workflow around.

The loop in eight stages

1. Intake → 2. Triage → 3. Case description → 4. Execution → 5. Review
                          [person                                ↓
                           approves]                        6. Checks
                                                            [person confirms]
                                                                 ↓
   ↑ ← ← ← ← ← ← ← 8. Monitoring ← ← ← ← ← ← ← ← ← 7. Release [person]

A coordinator runs above the loop. It is an agent that picks up a trigger, works out which stage a case is at, and starts the right agent with the right model and context. A cheaper model for sorting, a stronger one for descriptions, and for review whichever model scored best on your own test cases.

1. Intake: work arrives in one place

Complaints from email, from the web form, from the phone and from account managers land in one queue. A factory that work enters through six doors does not know what is on its plate, and you cannot measure time or cost in it. Without this stage half the cases bypass the loop and leave no trail.

2. Triage: the cheapest saving in the loop

An agent reads the claim, reconstructs the case from the systems (order, dispatch, invoice, customer history) and puts it into one of three bins. Ready to execute: a shortfall confirmed by the dispatch note, a small amount. Unclear, needs a description: damage without photos, a dispute over terms. Parked, needs a person: a key account, a legal matter, a commercial call. Your most experienced people get cases already sorted. Without triage, the execution agent receives a vague task and efficiently solves the wrong problem.

3. Case description: where the quality of the loop is decided

For unclear cases an agent prepares a short description: what happened according to the documents, what the contract and the complaints policy say, which decision it proposes and why. In software the equivalent is the product and technical specification written before any code. A person reads it, corrects it and approves it before anything is executed.

This is the control point with the most leverage. Fixing a sentence in a description costs a minute. Reversing a credit note already issued and apologising to the customer costs a day. Without this stage, a person looks at a finished result and tries to guess what the agent meant to do.

4. Execution: the least interesting stage

An agent prepares whatever follows from the approved description: a draft credit note, a collection order, a reply to the customer. Everyone wants to start here, because this is where the effect shows. That is a mistake. If intake, triage and description work, execution is the most predictable part of the loop. If they do not, a fast execution agent produces things people then reject.

5. Review: the stage that teaches itself

A second agent checks the result before a person sees it: does the credit note match the description, does the reply promise more than the policy allows, does the tone suit the customer. It has the approved description in front of it, so it judges the result against the intent, not just against a template.

Then there is an outer loop. Another agent collects the comments people leave when they approve, and from time to time proposes a change to the reviewer’s instructions. That proposal is an ordinary change for a person to accept. The team’s conventions do not have to be written up front in a document nobody reads. They build up in the instructions with every comment. Without this stage, a person makes the same five corrections every week.

6. Checks: a person confirms instead of redoing

An agent checks the result in the real systems: does the credit amount match the invoice, did the collection order reach the carrier, does the stock level add up. It attaches the evidence to the case. In software, the agent at this stage starts the application, walks the user’s path and records it. For the person, the nature of the work changes: instead of checking five systems themselves, they look at a summary with evidence and say yes or no.

7. Release: the decision that stays with a person

A person approves and sends: the credit note goes to the customer, the reply goes out, the refund starts. This is the moment risk passes from the company to the customer, or the other way round. Someone has to sign for it. The agent prepares, checks and proposes. A person decides and answers for it.

8. Monitoring: the loop closes

An agent watches what happens after a case closes. Did the customer come back with the same problem. Is the same product, or the same carrier, turning up in complaints more often than usual. When it sees a pattern, it opens a new item that returns to intake, this time for purchasing or quality. Without this stage the factory is a line that handles consequences efficiently. With it, the factory starts to show causes.

The second loop: a factory that improves the factory

Above the loop of cases runs a second, less visible one. An observer agent scores every run: what it cost, how many times a person had to correct something, whether the case came back. On that basis it proposes changes to the factory itself: a different model for triage, a sharper instruction for descriptions, a new rule for the reviewer.

To make this safe, the factory’s definition has to be kept like code: versioned, with the option to roll back a bad change and to compare a new version on a fixed set of test cases. That definition should live with you, as we argued in the piece on who owns the agent factory. A change to the factory takes the same route as a case: proposal, review, a person’s approval. A factory that rewrites its own instructions without human consent is, three months later, doing things nobody understands.

The old workflow and the factory

DimensionRelay of peopleAgent factory
Shapelinear handoversa loop in which monitoring feeds intake
Where people lookat the finished resultat the description before execution and the evidence after checks
Most expensive resourcepeople’s timehuman attention at decision points
Team knowledgein heads and an out-of-date manualin agent instructions, with change history
Controlspot checks, when someone has timeevery case, with evidence
Improvementa meeting once a quarterevery run scored, changes proposed
Work in progressin individual inboxesvisible, in one queue
Accountability for the decisiona personstill a person

The last row matters most. Rules, policy, approving the description and deciding on the release stay with people. Everything in between changes.

Where the factory does harm

Automatic execution of cases that only look simple. “One unit short, issue a credit note” sounds like a job for an agent. Until it turns out this customer has different terms in the contract, or this is the third shortfall this month and the case belongs to the account manager. Start with cases where a mistake is cheap and shows immediately.

Skipping the description because the agent is quick anyway. Fast execution without an approved description is the most expensive way to find out that everyone understood the case differently.

Self-improvement without a brake. A change to the factory without a person’s approval is drift, not progress.

A factory without people. A team told that the factory is there to replace them will leave, or stop correcting the instructions, before the factory starts working. The people who know the hardest cases will take to building the factory fastest if it comes as more responsibility, not as a verdict.

How to tell the factory is working

Vanity metricOutcome metric
replies drafted by agentshow many times a person touched one case from intake to release (should fall)
tokens usedcost of one closed case, and its trend month to month
agents runningshare of cases that went through the loop with no corrections after approval
“agents handle most complaints”time from claim to decision, and share of cases that come back
in software: lines of code written by agentsin software: the four DORA measures, namely lead time for changes, deployment frequency, change failure rate and time to restore service

A second model scoring quality can be a supplement. But if the number of returning cases is rising, no model’s score will hide that the factory is working worse. The numbers only mean something against the state before the change, which is why you measure the baseline before the first agent, as in the piece on measuring the baseline.

The order to build in

The key rule: every step leaves a working system. You can stop after any of them and still have something that pays its way. This is a pilot measured in weeks, not a year-long programme, for the reason set out in the piece on six weeks of software.

  1. Triage. An agent sorts incoming complaints into three bins and drafts a first solution for the obvious ones. Result: people stop spending hours working out what has actually arrived.
  2. Descriptions. For unclear cases an agent drafts a description with a proposed decision, and a person approves it. Result: harder cases enter the loop instead of waiting in an inbox.
  3. Review with a learning loop. Every result gets a first review before a person sees it, and people’s comments flow into the instructions.
  4. Checks in the systems. An agent checks the figures and attaches evidence. A person confirms instead of redoing.
  5. Connect and measure. The coordinator links the stages, monitoring feeds intake, the observer scores the runs. Only now does the second loop start to work.

After each step there is a real decision: carry on, change direction, or stay where you are. That decision belongs to the people who bear the cost of the change, not to a status slide, as we wrote in the piece on the steering committee. And once the loop works in one team, moving it to the next is a separate project, as in the piece on scaling after a pilot.

The last step is handover. The loop definition, the instructions and the evaluations should live in your repository and be run by your team, not by whoever built the factory. That is how VUCALE works: frame, build, hand over.

A test for this week

Take the last twenty complaints or tickets from your system and, by hand in a spreadsheet, assign each to one of the three triage bins. If more than half land in “unclear”, the first agent in your factory should not be the one that executes. It should be the one that writes descriptions.

What remains is a decision. You can give the team an agent that executes faster and watch the queue for checking grow. Or you can build a loop in which people stop doing and reviewing everything, and start approving what genuinely needs their judgement.