5 QA Patterns for Multi-Agent AI

First written in February 2026, when Savra ran a multi-agent architecture. We have since moved to a single agent with dynamically activated skills, and the reasons are in Don't Go Multi-Agent. The patterns below outlived the architecture: the review layers are about how much verification a task deserves, which is a question you answer the same way whether the reviewer is a separate agent or a second pass.

Language models produce confident text. Whether that text is true is a separate property, and nothing in the generation process distinguishes the two.

In production that shows up as a research answer citing sources that do not exist, a support agent inventing a policy, or a code suggestion that will not compile. With no review step, the path from a plausible fabrication to your user is a straight line.

The fix is a review layer sized to what a wrong answer actually costs. Here are the five, from cheapest to most thorough.

Pattern 1: no review

1User → Agent → Response

Output goes straight to the user. Sub-second added latency, no extra calls, no infrastructure.

It is the right answer more often than people admit. A lookup whose result the user can eyeball, an internal tool used by people who know the domain, anything where speed is the product. What you give up is any safety net at all, and consistency: quality varies request to request and nothing notices.

Pattern 2: self-critique

1User → Agent → Self-review → Response

The model checks its own work before answering, inside the same generation:

1system_prompt = """
2After generating your response, ask yourself:
31. Did I cite real sources?
42. Is my code syntactically correct?
53. Did I answer what was actually asked?
6
7Revise if needed, then respond.
8"""

No extra API call, and roughly 10 to 20% longer responses. It catches the mechanical failures well: syntax errors, missing pieces, answers that wandered off the question.

Its limit is structural. A model cannot catch a hallucination it is still having, because the thing doing the checking holds the same belief as the thing being checked. Self-critique improves craft, not truth.

Best for code agents, writing assistants, and anything where the likely errors are errors of execution.

Pattern 3: supervisor review

1User → Agent → Supervisor → Response (or reject)

A second agent reviews before delivery:

1class QAReviewResult(BaseModel):
2    approved: bool
3    feedback: str | None
4    revised_response: str | None

A rejection sends feedback back to the original agent, which tries again.

This is the first pattern that catches confident nonsense, because the reviewer does not share the author's assumptions. It costs an extra call, two to three seconds, and about twice the tokens. It also rejects good answers sometimes, and a strictness dial you never tune will either wave everything through or block work that was fine.

Best for customer-facing conversation and general assistants, where accuracy outranks speed but not by enough to involve a person.

Pattern 4: human approval

1User → Agent → [Wait for a human] → Response

Output is held until someone approves it:

1if qa_pattern == "human_approval":
2    await send_approval_request(agent_response)
3    approval = await wait_for_human_decision()
4    if not approval.approved:
5        return handle_rejection(approval.feedback)

The most accurate pattern available, and the only one that produces an audit trail worth showing a regulator. It is also blocked on human availability, does not scale past the people you have, and interrupts whatever the user was doing.

Worth it when a wrong answer is expensive and a slow answer is not: contracts, policies, regulated advice, and creative work going out under someone's name.

Pattern 5: double review

1User → Agent → Self-critique → Supervisor → Response

Both layers, in order:

1# Step 1: the agent self-critiques
2response = await agent.run(query, self_critique=True)
3
4# Step 2: the supervisor reviews
5review = await supervisor.review(response)
6
7if review.approved:
8    return response
9else:
10    return await agent.revise(response, review.feedback)

Two passes of verification catches the most, at two extra passes of latency and roughly three times the tokens. On a simple query it is pure waste.

Best where a wrong answer causes harm: research that will be cited, anything legal or medical, anything a reader will act on without checking.

Choosing between them

Two questions decide it, and neither is about the technology:

1QA_PATTERNS = {
2    "none":                 {"latency": "fastest",  "quality": "variable"},
3    "self_critique":        {"latency": "fast",     "quality": "good"},
4    "supervisor_qa":        {"latency": "moderate", "quality": "high"},
5    "human_approval":       {"latency": "slowest",  "quality": "highest"},
6    "self_plus_supervisor": {"latency": "moderate", "quality": "highest"},
7}

Whichever you pick, you need to see it working: rejection rates by agent and the reasons attached are exactly what tracing every agent run is for. The same applies to what the reviewer is checking for, since the stock AI phrasing worth banning outright is easier to catch with a rule than with judgement.

The mistake worth avoiding is picking one pattern for the whole system. Stakes vary per task, not per product, and a research answer someone will quote deserves more scrutiny than a request for today's date. Configure it per agent, or per skill, and the fast paths stay fast.

FAQ

What is the cheapest QA pattern that actually helps?
Self-critique. No extra call, 10 to 20% longer responses, catches mechanical errors and misses the model's own hallucinations.

Why does a separate reviewing agent catch more than self-critique?
It does not share the first model's assumptions, so it can notice confident nonsense. It costs an extra call and roughly double the tokens.

When is human approval worth the friction?
When a wrong answer is expensive and a slow one is not, and when you need an audit trail.

Should every agent use the same QA pattern?
No. Match the pattern to the stakes of the task, per agent or per skill.