Skip to content

Bridging Requirements and Architecture: Multi-Agent Orchestration with External Knowledge and Hierarchical Memory

🕒 Published (v1): 2026-05-31 18:18 UTC · Source: Arxiv · link

Why this paper was selected

Multi-agent orchestration with external knowledge and hierarchical memory for architecture

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

MAAD is a multi-agent framework that automates software architecture design by orchestrating four specialized agents (Analyst, Modeler, Designer, Evaluator) in a feedback-driven pipeline that transforms a Software Requirements Specification into multi-view architectural blueprints. It augments agent reasoning with RAG-injected architectural standards and a three-tier hierarchical memory (working, episodic, semantic). Against MetaGPT on 10 case studies, MAAD produces more complete, modular, and traceable architectures.

Problem

Existing LLM-based approaches to software architecture design are either single-agent (prone to hallucination and cross-view inconsistency) or generic multi-agent frameworks (e.g., MetaGPT) that are code-centric and lack architecture-specific workflows, domain knowledge integration, and systematic quality evaluation. Architects still bear the full cognitive burden of translating ambiguous requirements into consistent multi-view designs, with limited cross-team knowledge reuse.

Method

MAAD instantiates four role-specialized LLM agents in a sequential, feedback-gated pipeline:

  1. Analyst — parses the SRS into Functional Requirements (FRs), Non-Functional Requirements (NFRs), and Architecturally Significant Requirements (ASRs).
  2. Modeler — constructs "4+1" view architectural models (Kruchten) from the Analyst's artifacts.
  3. Designer — synthesizes final architecture documentation from all upstream artifacts.
  4. Evaluator — performs per-stage quality gates using ATAM criteria, producing an ATAM evaluation report and a mismatch analysis report; triggers revision loops until quality thresholds are met.

Agents share an artifact pool and are supported by two orthogonal mechanisms: - RAG over a knowledge base of authoritative architecture literature, software project examples, and expert knowledge, injected at each agent's reasoning step. - Hierarchical memory: per-agent working memory (current context + evaluation feedback), per-agent episodic memory (design experiences from prior interactions), and a framework-level shared semantic memory (generalized architectural knowledge distilled from all past sources).

The pipeline is iterative: each stage's artifacts are evaluated before acceptance; if quality criteria are not met, the relevant agent revises until convergence.

Key Contributions

  • Four-agent architecture-specific orchestration protocol (Analyst → Modeler → Designer, with Evaluator gating every stage), producing "4+1" multi-view blueprints plus ATAM and mismatch reports.
  • Three-layer hierarchical memory mechanism enabling cross-task knowledge reuse, reduced hallucination, and iterative refinement without re-processing full history.
  • RAG-based external knowledge infusion strategy grounding agent decisions in recognized architectural standards and patterns.
  • Empirical evaluation across 10 case studies (quantitative metrics vs. MetaGPT) and qualitative validation with industry architects on 10 real-world specifications.
  • LLM backbone comparison: GPT-5.2, Qwen3.5, DeepSeek-R1, Llama3.3 as MAAD foundations.

Results

  • MAAD outperforms MetaGPT on completeness (coverage of required architectural views, components, interfaces, deployment elements), structural modularity, cohesion, and interface contract explicitness across 10 case studies.
  • MAAD-generated architectures exhibit lower structural complexity and higher cohesion than MetaGPT baselines (specific metric values not reported in the provided text).
  • The Evaluator agent autonomously produces structured quality reports, significantly reducing manual validation effort (qualitative finding from industry architects).
  • GPT-5.2 and Qwen3.5 as backbone LLMs consistently outperform DeepSeek-R1 and Llama3.3 across most architectural quality metrics within the MAAD framework.
  • Industry architects confirm the framework delivers coherent, principle-aligned architectural designs suitable for real-world development.

Limitations

  • Evaluation is limited to 10 case studies; generalizability to larger or more diverse systems is unconfirmed.
  • Quantitative metrics measure structural properties (completeness, cohesion, complexity) but cannot fully capture semantic correctness or long-term maintainability of the generated architectures.
  • Performance is strongly dependent on the backbone LLM's reasoning capacity, making results contingent on model availability and cost.
  • The RAG knowledge base construction process and its effect on output quality are not fully ablated in the provided text.
  • No comparison against human architects on cost/time trade-offs or correctness at the implementation level.

Relevance to Harnesses / Meta-Harnesses

MAAD is a concrete instance of a domain-specific multi-agent harness: it hard-codes an agent topology (Analyst → Modeler → Designer + Evaluator gate), inter-agent protocols, a shared artifact pool, and a hierarchical memory system into a reusable orchestration framework — exactly the structural pattern meta-harnesses generalize. The feedback-gated, iterative stage design (evaluate → revise → accept) is a harness-level control-flow primitive, not application logic, and the separation of per-agent working memory from shared semantic memory mirrors the state-management challenge any meta-harness must solve. For researchers building general-purpose agentic harnesses, MAAD offers a well-evaluated blueprint for how memory layering (working/episodic/semantic) and RAG integration can be wired into an orchestration loop to achieve iterative convergence without unbounded re-processing.