The first design people reach for is one large agent: give it all the documents, all the tools and a long set of instructions, and let it handle the whole job. It works in the demo. In production it goes wrong in ways nobody spots until a customer does.
Where one large agent goes wrong
- Long instructions pull against each other, and the model follows some of them and drops others without saying so.
- When the output is wrong, nobody can tell which part of the job failed.
- There is no clear right answer for "do everything", so there is nothing solid to test it against.
What we build instead
We split the work into small agents, each with one job and one kind of output, and connect them in a pipeline. For drafting client documents, a typical setup looks like this:
- A research agent pulls the relevant facts from your documents and records where each one came from.
- A drafting agent writes the document from those facts and nothing else.
- A checking agent compares the draft with the facts and your rules, and flags anything it cannot support.
- A person reads the flagged draft and approves it before it goes anywhere.
Why it holds up better
Each agent can be tested on its own against real examples, so we know how good it is before launch and can see when it slips. Each can run on a different model, a small cheap one for sorting and a stronger one for writing. And the person reviews at the one step where a mistake would be expensive, instead of checking every intermediate output.
A question to ask whoever builds yours
Ask how they will know if the answers get worse after launch. If the reply does not include a set of test cases and some monitoring, expect the quality to drift without anyone noticing.
