I had a call flow to build for a 30-minute sales demo. One page, the kind of thing you keep open on a second monitor and follow while on the call. It needed an opening, a discovery section, a product walkthrough, branching paths for when the call goes sideways, objection handling, a close, all the things a good sales call should have.
The obvious way to do this with AI is to hand the whole brief to one agent and let it write the document. Instead, I split the job across three agents, set them against each other, and let the loop run. What came back was, in my engineer-brained opinion, better than anything a single-agent run would have handed me.
I've been calling it adversarial collaboration, though I lay no claim to the idea or the coining of the term. The writer-critic loop is one of the most worked-over patterns in agent design, and Kahneman used the same phrase decades ago for good-faith fights between rival experts with a referee in the middle. The only difference here is who holds the pen and who sits in the referee seat.
Three Roles, One Document
I set up three agents, each with a narrow job and hard limits:
The builder owned the document. It was the only agent with write permissions, so every change to the page went through it. Its job was to keep the document coherent and get it shipped.
The breaker played the skeptical buyer, the kind who shows up with objections already loaded. It had no write permissions to the document at all. If it wanted to change a single word, it had to convince the builder: send a critique, propose a replacement line, make the case. Its job was to find every place a real buyer would stall, check out, or start to smell a pitch.
The referee drove the loop. It didn't write copy and it didn't attack it. When the other two deadlocked, it made the call. Its job was to hold the line on the facts so that neither builder nor breaker could drift into a claim I couldn't back up.
My part happened at the edges. All three agents got the same background research up front, so every argument was measured against the same facts, and the referee got one standing order from me: accuracy beats punch. Then, I kicked off the loop and stayed out of it. My other job came at the end: fact-checking the finished page before anything shipped.
How It Ran
The whole thing ran in a single Claude Code session: the referee was the session's main agent, with the builder and the breaker as two background subagents it drove. The breaker's critiques reached the builder as direct agent-to-agent messages, and the builder decided what to fold in while the referee enforced the hard facts and broke the ties.
The builder drafted first. Then the referee set the breaker loose for a hostile read, and it came back with specific complaints and replacement lines. The builder kept whatever held up and ignored the rest. Then the loop went around again. Draft, attack, revise, re-read: it ran that circuit many more times than I'd have had the patience to sit through, and it kept going until the referee judged the document had converged and called it done.
Anatomy of a Round
The fight that best shows what each role was for happened over exit terms. Every vendor is familiar with the objection: the buyer who got burned last time and wants to know, before anything else, how difficult it is to leave. The breaker's proposal was to kill that fear before it could surface by framing the exit as leave whenever, cancel anytime. As a line in a sales call it's nearly perfect, as it answers the objection before it's spoken and costs nothing to say.
However, in our case, it simply wasn't true. The contract has a one-year term and a defined 60-day paid pilot with an escape clause, and "cancel anytime" walked straight over both. A buyer who read the paperwork after the call would catch it, and the trust the line had bought would be gone.
In the end, each role did its job. The breaker had already done its part by forcing the issue: the fear is real, and the document had to answer it. The referee checked the claim against the contract terms in the research and ruled the framing out. Accuracy beats punch. That left the builder with rebuilding the same reassurance out of terms the contract could support, resulting in this:
"Here you approve every page, you own all of it, and on exit you get a full export plus 90 days of hosting while you migrate.
Same answer to the same fear, made entirely of claims that survive the buyer checking them: leaving is clean, and everything you paid for goes with you.
This is the exact spot where a single agent fails. It writes the cancel-anytime line, grades its own work, and the line stays in. Here, the agent that wanted the line couldn't ship it, the agent that could ship it didn't write it, and the agent that judged it had the contract in hand.
Why I Think It Worked
A few things came out of splitting the work this way.
The author wasn't also the critic. When one agent drafts and then judges its own draft, the weak spots get rationalized away by the same reasoning that created them. Splitting the jobs meant the criticism came from somewhere with no stake in the draft looking good.
Every line had to survive a hostile read. Nothing reached the page just because it sounded nice. It had to get past an agent whose entire job was to act like the buyer most likely to push back.
The document kept one voice. Critique came from both sides, but edits came from one place, so the page never turned into design-by-committee, where every agent leaves a fingerprint and the whole document reads like a giant conflict.
The pressure was aimed before the loop started. The breaker wanted the document to hit harder; the referee's standing order let it hit exactly as hard as the facts could back up, and no harder. My judgment went in at the edges instead of into every round: the rules and the research up front, a fact-check at the end.
What I'd take from this:
- Separate the writer from the critic. Don't let one agent grade its own work.
- Give the critic teeth but no pen: it changes the doc only by convincing the writer, which keeps the output coherent.
- Make the referee an agent too, with the same facts and clear rules for breaking ties. That's what lets the loop run more rounds than you'd sit through yourself.
- Put your own judgment at the edges: rules and research before the loop, a fact-check/quality check after. You can always iterate and run the loop again.
A Caveat on Scope
I ran this on one document. I don't have conversion numbers, I haven't split-tested the call flow against a single-agent version, and one good result isn't a framework. What I can say is that for work that has to be persuasive and true at the same time, splitting the writing from the criticism, and handing the refereeing to an AI agent with far more patience than me produced a page I trusted more than I usually trust a first pass.
If you try a version of this, or you've got a better way to split the work, I'd like to hear about it. Feel free to reach out on socials or send me an email.