Testing Multi-Agent Systems

Picture shipping an agent team that passed every unit test you wrote and then failed in production on its very first real request. It happens constantly, and the reason is specific: teams test each agent in isolation with mocked inputs, and every agent passes, but the interactions between agents - the seams where one agent's output becomes another's input - go untested. To test a multi agent system well, you have to test the seams, the non-determinism, and the failure paths, not just the individual agents doing their happy-path job.

This is harder than testing ordinary software because agents are non-deterministic - the same input can produce different outputs - and because the interesting failures emerge from combinations, not units. But it's far from impossible. There's a concrete toolkit for it, and most teams simply haven't been shown it because agent testing practice is younger than the systems themselves.

What Does It Mean to Test a Multi Agent System?

To test a multi agent system means verifying not just that each agent works alone, but that the team produces correct results together, handles the messy inputs agents actually pass each other, and degrades sensibly when parts fail. That's three distinct testing concerns - unit correctness, interaction correctness, and failure behavior - and the second two are where the real bugs live.

The central challenge is non-determinism. A traditional test asserts "input X produces output Y." An agent might produce Y, or Y-prime, or occasionally Z. So exact-match assertions on agent output are brittle - they fail on harmless variation and pass on subtle degradation. You need testing approaches that tolerate acceptable variation while catching genuine regressions, which is a different discipline than asserting equality.

[object Object],
,[object Object], ,[object Object],():
    ,[object Object], agent.summarize(doc) == ,[object Object],

,[object Object],
,[object Object], ,[object Object],():
    out = agent.summarize(doc)
    ,[object Object], ,[object Object], ,[object Object], out              ,[object Object],
    ,[object Object], ,[object Object],(out.split()) < ,[object Object],     ,[object Object],
    ,[object Object], ,[object Object], contains_hallucinated_numbers(out, doc)

What this does: The first test breaks the moment the agent rephrases, even correctly. The second asserts the properties a good summary must have - the key fact is present, it's actually brief, it invents no numbers - which pass on acceptable variation and fail on real problems. Property-based assertions are the foundation of testing non-deterministic agents.

Why It Matters

Untested interactions are where agent teams break, and the breaks are expensive because they surface in production. When agent A's output format drifts slightly and agent B silently misparses it, no unit test catches it - both agents "work." The failure only appears when they run together on real data, which is to say, in front of a user.

Three scenarios where seam-testing earns its keep:

A healthcare startup had a triage agent feeding a recommendation agent. Both passed unit tests. In production, the triage agent occasionally emitted a severity field in a format the recommender didn't expect, and recommendations silently defaulted to "low priority." A contract test on the seam - asserting the triage output always matched the schema the recommender required - would have caught it before launch.

A legal-tech team's document pipeline passed all tests until a real contract with unusual formatting flowed through. Each agent had been tested on clean inputs; none had been tested on the adversarial inputs the previous agent could actually produce. Testing with realistic, messy intermediate data surfaced the bug.

A logistics company's agent team worked in tests and stalled in production when a downstream service was slow, because no test covered the failure path - what happens when an agent's dependency times out. Failure-injection testing would have revealed the missing timeout handling.

⚡ Pro tip: Test the seams before the units. In a multi-agent system, the highest-value tests assert that each agent's output conforms to the contract the next agent expects. Unit tests catch an agent being wrong; contract tests catch the far more common and far sneakier bug of two agents disagreeing about a format. Spend your first testing effort on the boundaries.

How Do You Test a Multi Agent System Deterministically?

Non-determinism makes testing hard, so the first move is to remove it where you're not specifically testing it. Record real agent outputs once and replay them, so you can test your orchestration logic - the coordination, the routing, the error handling - against fixed, known agent responses.

[object Object], ,[object Object],:
    ,[object Object], ,[object Object],(,[object Object],):
        ,[object Object],.recorded = recorded   ,[object Object],

    ,[object Object], ,[object Object],(,[object Object],):
        ,[object Object], ,[object Object],.recorded[,[object Object],(task)]   ,[object Object],

What this does: It replaces a live, non-deterministic agent with recorded outputs, so a test of the surrounding system runs deterministically. Now you can assert that your orchestrator routes correctly, handles a specific agent output correctly, and recovers from a specific failure - without the flakiness of live model calls. You're testing the machinery around the agents with the agents held constant.

This separates two things that get conflated: testing the agents (does the model produce good output?) and testing the system (does the coordination work?). Replay lets you test the system deterministically, and you test the agents separately with property-based evaluation. Mixing the two is why so many agent test suites are simultaneously flaky and shallow.

⚡ Pro tip: Record a library of real agent outputs, including the weird ones, and replay them in system tests. The messy, surprising outputs your agents actually produced in the wild are the most valuable test fixtures you have, because they're exactly the inputs the next agent must handle and that a synthetic fixture would never think to generate. Capture production oddities and turn them into permanent tests.

How Do You Test Failure Behavior?

Most agent bugs that reach production are failure-path bugs - the system works when everything succeeds and breaks when something doesn't. So you have to test failure deliberately by injecting it: make an agent time out, return garbage, or crash, and assert the system responds sensibly.

[object Object], ,[object Object],():
    system = build_system(agents={,[object Object],: TimeoutAgent()})
    result = system.run(task)
    ,[object Object],
    ,[object Object], result.status == ,[object Object],
    ,[object Object], result.note == ,[object Object],

What this does: It swaps in an agent that always times out and asserts the system degrades gracefully rather than hanging or crashing. This tests the failure path that real dependencies will eventually exercise - and that happy-path tests never touch - so you find out your fallback works in a test instead of during an incident.

Inject each failure mode your agents can exhibit: timeout, invalid output, crash, and slow-but-working. Each should have a test asserting the team's response. This is the testing that actually correlates with production reliability, because production failures are overwhelmingly failure-path failures.

How Do You Test Agent Quality Without Flaky Tests?

Testing the system deterministically with replay is half the job; you also need to test the agents themselves, and that's where non-determinism can't be avoided - you're asking whether a model produces good output, which varies. The answer is to stop asserting single outcomes and start measuring rates across many samples.

Run each agent on a fixed evaluation set many times and track the pass rate against your property checks, not a single pass or fail. An agent that produces a good summary 98% of the time will occasionally fail a single-run test through pure variance, and that flakiness teaches the team to ignore the test. A rate-based check - "summary quality must hold on at least 95% of the eval set" - is stable, meaningful, and doesn't cry wolf.

[object Object], ,[object Object],(,[object Object],):
    passes = ,[object Object],(,[object Object], ,[object Object], ,[object Object], ,[object Object], eval_set
                 ,[object Object], meets_properties(agent.run(,[object Object],.,[object Object],), ,[object Object],))
    rate = passes / ,[object Object],(eval_set)
    ,[object Object], rate >= threshold, ,[object Object],
    ,[object Object], rate

What this does: It runs the agent across a whole evaluation set and asserts on the aggregate pass rate rather than any single result. This absorbs the natural variance of a non-deterministic agent - one unlucky output doesn't fail the suite - while still catching a genuine regression, which shows up as the rate dropping across the whole set rather than one flaky case.

Track that rate over time and you get a regression signal: when a prompt change or model update drops an agent's eval pass rate, you see it as a number moving, before the degradation reaches users. This is the agent-testing complement to the deterministic system testing - together they cover both "does the coordination work" and "do the agents still produce good output," which are the two questions a multi-agent test suite has to answer.

⚡ Pro tip: Assert on pass rates across an eval set, never on single agent outputs. A rate-based gate is the only kind that's simultaneously stable enough to keep enabled and sensitive enough to catch real regressions. Single-output assertions on non-deterministic agents are guaranteed to be either flaky or so loose they catch nothing - the rate is what escapes that trap.

Common Mistakes

⚠️ Common mistake: Testing agents only on clean, well-formed inputs when their real inputs come from other agents that produce messy, surprising output. An agent tested exclusively on tidy fixtures will meet its first realistic input in production. Feed each agent the actual range of outputs its upstream agents produce - including the malformed and the weird - because that adversarial-but-real input is what it must survive, and clean fixtures give false confidence.

The second mistake is asserting exact output equality on non-deterministic agents, which produces flaky tests that teams eventually disable - and a disabled test protects nothing. Use property assertions instead.

The third is skipping failure-injection because "it works in testing." It works in testing because testing only exercises the happy path. Inject failures or you're shipping untested failure handling, which is where production breaks.

Conclusion

To test a multi agent system, go past isolated unit tests: assert output contracts at the seams, replay recorded outputs to test coordination deterministically, use property assertions to tolerate acceptable variation, and inject failures to verify graceful degradation. That combination catches the interaction and failure bugs that unit tests structurally cannot, which are exactly the bugs that reach production.

Keep your contract schemas, property assertions, and recorded test fixtures versioned so your test suite stays reproducible. I store the contract definitions and the property-assertion prompts in PromptABCD, because the schemas encode what each agent seam requires and the property checks encode what "good output" means, and reusing those across projects means a new agent team inherits a tested set of expectations instead of starting from zero test coverage.

⚡ Pro tip: When a bug reaches production, capture the exact inputs that triggered it and add them to your replay fixtures before you fix it. Every production failure is a test case you didn't have - turning it into a permanent replayable fixture means that specific bug can never silently return, and over time your fixture library becomes a precise map of every way your system has actually broken. Regression coverage that grows from real incidents beats coverage you tried to imagine up front.