Multi-agent Architecture

Multi-Agent Architecture – a Gemini-powered system for deterministic cloud architecture reviews.
Specialized AI agents for Cost, Performance, and Reliability working in parallel on architecture analysis.
Deterministic multi-agent workflow orchestrated using n8n with aggregation, validation, and consensus.
Interactive frontend where users define system requirements and trigger multi-agent evaluation.
Final consolidated architecture review with validated findings, risk scores, cost estimate, and diagram.

Inspiration

Modern system design is rarely a solo activity. In real engineering teams, architecture decisions emerge from multiple perspectives—FinOps teams evaluate cost, performance engineers focus on latency and scale, and SREs worry about reliability and failure modes.

However, most AI tools today generate single, monolithic answers, which do not reflect how real architecture reviews happen. This often leads to generic advice, missed trade-offs, and outputs that cannot be reliably reused or validated.

The inspiration behind Multi-Agent Architecture was a simple question:

Can we make AI reason about system design the way real engineering review panels do—collaboratively, critically, and deterministically?

This project explores that idea using Gemini 3 as the reasoning engine behind multiple specialized agents.

What It Does

Multi-Agent Architecture is a system that evaluates cloud architectures using multiple collaborating AI agents, each with a clearly defined responsibility.

Given a set of system requirements, the platform: • Normalizes raw user input • Runs parallel AI agents for: • FinOps (cost analysis) • Performance • SRE / Reliability • Aggregates structured outputs • Validates findings through a Critic (Lead Auditor) agent • Produces a single, deterministic architecture review including: • validated and rejected findings • risk scores • estimated monthly cost • actionable recommendations • an automatically generated architecture diagram (Mermaid)

All outputs are returned as strict JSON, making the system safe to consume both by humans and downstream tools.

How We Built It

The project is built as a deterministic multi-agent pipeline, powered by Gemini 3 and orchestrated through a workflow engine.

Architecture Overview 1. Frontend UI Allows users to input system requirements and visualize outputs, including diagrams and structured reports. 2. Normalizer Agent Converts free-form requirements into a consistent structured format. 3. Specialized Gemini Agents • FinOps Agent → cost estimates and financial risks • Performance Agent → latency, throughput, and scaling analysis • SRE Agent → availability, failure modes, and recovery strategies 4. Aggregation Layer Combines agent outputs while handling partial failures and missing data safely. 5. Critic Agent (Lead Auditor) Classifies findings as validated or rejected, enforcing strict pass-through of numeric data such as: \text{risk_score}{final} = \sum{i=1}^{n} \text{risk_score}_i (conceptually aggregated, without modifying individual scores) 6. Consensus Engine Produces the final architecture review in strict JSON and generates a Mermaid-based architecture diagram.

A strong emphasis was placed on schema enforcement, error handling, and determinism to avoid hallucinations and nondeterministic outputs.

Challenges We Ran Into

One of the biggest challenges was handling partial failures in multi-agent systems. Large language models do not guarantee responses every time—agents may time out, return empty outputs, or fail safety checks. Without safeguards, this breaks aggregation logic.

Another challenge was enforcing strict JSON outputs while still allowing Gemini 3 to reason deeply. This required careful prompt design, fallback mechanisms, and validation steps to prevent malformed responses.

We also faced issues with workflow nondeterminism, where timing differences or empty branches caused intermittent failures. Solving this required designing the system to tolerate missing agents without collapsing the entire pipeline.

Accomplishments We’re Proud Of

• Built a deterministic multi-agent system, not just a single-prompt AI
• Enforced strict output contracts across all agents
• Implemented a Critic + Consensus pattern to reduce hallucinations
• Generated usable architecture diagrams automatically
• Designed the system with production-oriented reliability, not just a demo mindset

What We Learned

We learned that reliable AI systems are less about prompting and more about orchestration, validation, and failure tolerance.

Multi-agent architectures amplify both the strengths and weaknesses of LLMs. While Gemini 3 excels at multi-step reasoning and collaboration, building trustworthy systems requires: • explicit data contracts • defensive aggregation • and deterministic pipelines

Most importantly, we learned that AI can meaningfully assist system design only when it mirrors real engineering processes, not when it replaces them with a single answer.

What’s Next

Next steps for Multi-Agent Architecture include: • Adding security and compliance agents • Introducing agent confidence scoring and weighted consensus • Exporting deployment-ready outputs (IaC and design docs) • Integrating architecture reviews into CI/CD pipelines • Supporting more system types and cloud providers

Our long-term goal is to make system design repeatable, auditable, and AI-assisted, while keeping humans in control of the final decisions.