How Generation Architecture Shapes Code Complexity in Multi-Agent LLM Systems: A Paired Study on HumanEval

A paired study comparing six multi-agent LLM architectures across 1,968 code generation tasks reveals that architectural complexity increases code structural complexity by 50-130% without improving functional accuracy. The research demonstrates that simpler orchestration pipelines match or exceed performance of elaborate multi-agent systems, challenging assumptions about architectural elaboration in AI code generation.

This research addresses a critical blind spot in LLM code generation evaluation: while the field has obsessed over functional correctness metrics, the structural quality and maintainability of generated code has remained largely unmeasured. The study systematically examines how different multi-agent orchestration patterns—analyst, coder, tester, and debugger components—affect code complexity using established RADON metrics, uncovering that architectural choices carry hidden costs.

The findings reveal two distinct complexity clusters separated by substantial gaps, with the analyst-coder interaction being the primary complexity driver. Notably, runtime debuggers reduce complexity while testers reinflate it, suggesting that post-execution feedback loops have differential effects on code generation patterns. This granular layer analysis provides actionable insights absent from prior work that only examined prompt-level effects.

For the AI development community, these results challenge the prevailing assumption that more sophisticated orchestration automatically produces better outcomes. The leanest architectures matching or beating elaborate pipelines on accuracy suggests that teams can achieve equivalent or superior results with simpler systems, reducing inference costs and latency. This has direct implications for production deployments where computational efficiency and maintainability matter alongside correctness.

The research introduces methodological rigor through paired non-parametric statistics across 164 benchmark tasks and two model families, strengthening confidence in the findings. Looking forward, this establishes a template for evaluating architectural choices beyond single metrics, potentially reshaping how code generation systems are evaluated and deployed in practice.

• →Multi-agent LLM architectures increase code complexity by 50-130% without improving pass@1 accuracy rates.
• →Simpler orchestration pipelines (Basic, AC) produce code matching or exceeding the accuracy of elaborate systems (AC+Debugger, ACT+Debugger).
• →The analyst-coder interaction is the primary source of complexity inflation in multi-agent code generation.
• →Runtime debuggers reduce code complexity while tester components re-inflate it, revealing differential layer effects.
• →Architectural choices in LLM code generation should be justified by measured performance benefits rather than assumed improvements.