Multi-agent cooperative building scheme layout distributed design system

Abstract

The application discloses a kind of multi-Agent collaborative building scheme layout distributed design system, including distributed Agent service layer, knowledge service layer, collaborative middleware layer and man-machine interaction layer.Distributed Agent service layer is formed by multiple Agent service nodes, which are divided according to the professional functions of building design and independently deployed.Each node encapsulates general capability unit and role specialization unit, realizes atomization of capability and reusable combination.Knowledge service layer provides structured knowledge support through double-path knowledge base, hybrid retrieval mechanism and hierarchical knowledge graph.Collaborative middleware layer realizes decoupled interaction between nodes and full-process traceability through structured communication protocol, publish / subscribe, message pool and shared workspace.The man-machine interaction layer embeds user professional judgment into the design cycle.The application solves the problems of existing design system capability coupling, insufficient knowledge support and collaborative black-box, and improves the system robustness, knowledge retrieval accuracy and design quality.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence-assisted architectural design technology, specifically to a distributed design system for architectural layouts that facilitates multi-agent collaboration. Background Technology

[0002] Architectural layout design is a crucial upstream link in the architectural engineering design chain. Its essence lies in mapping multi-dimensional constraints such as site boundaries, functional requirements, area indicators, spatial relationships, and building codes into specific spatial organization schemes. This encompasses highly specialized tasks including site condition analysis, code retrieval, historical case reference, functional zoning, and circulation planning. Especially in the design of multifunctional public buildings such as medical, educational, and office buildings, designers need to simultaneously coordinate dozens of mandatory code provisions, complex clean and contaminated area zoning and patient / medical circulation relationships, and variable site conditions. Design decisions heavily rely on the accurate acquisition of professional knowledge and the comprehensive balancing of multiple objectives.

[0003] With the development of artificial intelligence technology, the intelligent generation of architectural layout schemes mainly follows the following three technical routes.

[0004] The first technical approach is based on neural network-based layout generation methods. These methods are represented by generative adversarial networks (GANs) and diffusion models. For example, House-GAN (European Conference on Computer Vision, 2020), proposed by Nauata et al., encodes room types and spatial adjacency relationships as graph constraints for planar generation; its improved version, House-GAN++, introduces an iterative refinement mechanism to improve generation quality; and LayoutDM (Proceedings of the IEEE / CVF Conference on Computer Vision and Pattern Recognition, 2023, Chai S), proposed by Chai et al., combines a Transformer architecture to enhance the global dependency modeling capabilities of diffusion models. This type of method has two inherent drawbacks: First, data-driven implicit learning heavily relies on large-scale labeled samples, while building floor plan data is stored in unstructured forms such as CAD files and PDF images, resulting in high labeling costs and strong data heterogeneity. Most publicly available high-quality datasets are limited to residential scenarios, causing data-scarce building types such as medical and educational institutions to remain outside the technology's coverage for a long time. Second, black-box generation lacks explicit modeling of building codes and functional constraints, making it difficult to bridge the gap between the generated scheme and actual engineering needs.

[0005] The second technical approach is layout generation methods based on large language model reasoning. For example, LayoutGPT (Advances in Neural Information Processing Systems, 2023, Feng W), proposed by Feng et al., uses a large language model as a visual planner to generate layouts from text descriptions; LayoutCoT (arXiv preprint platform, 2025, Shi H), proposed by Shi et al., combines retrieval-enhanced generation with thought chain technology to achieve training-free layout reasoning. These methods mostly remain in a single-agent sequential generation mode, constrained by limited context windows and a lack of domain-specific tools. When handling cross-document canonical retrieval, multi-objective constraint coordination, and spatial geometric reasoning tasks, the output quality is difficult to meet engineering requirements. Furthermore, the cognitive load is concentrated in a single reasoning chain, and context expansion in long-chain reasoning leads to a sharp performance degradation.

[0006] The third technical approach is a general multi-agent collaborative framework. For example, MetaGPT (The Twelfth International Conference on Learning Representations, 2023, Hong S), proposed by Hong et al., encodes standardized operating procedures into prompt sequences and uses a message pool mechanism to achieve multi-role collaboration in software development tasks; ChatDev (Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics, 2024, Qian C), proposed by Qian et al., uses a waterfall model to organize agent collaboration throughout the entire software development process. However, the frameworks of the above technical approaches are all geared towards general scenarios such as software development and machine translation. Their agents only have general tools and general prompt word configurations. They do not establish atomic and reusable professional capability encapsulation for architectural design processes, nor do they have a structured knowledge service system for building codes and design cases. Agents often communicate directly using unconstrained natural language, resulting in loose information structure, high ambiguity, and difficulty in process traceability. Furthermore, the overall design process operates as a black box, and users' professional judgments cannot be embedded in the execution loop. Existing explorations in the field of architecture, such as MANSION (arXiv preprint platform, 2026, Che L) proposed by Che et al., which focuses on the generation of 3D scenes of multi-story buildings, and MedBuild AI (arXiv preprint platform, 2025, author Zhang Y) proposed by Zhang et al., which is aimed at medical building planning, have not solved the system engineering problems such as the atomic encapsulation of agent capabilities, structured knowledge services, and traceability of collaborative processes.

[0007] Furthermore, from a system architecture perspective, existing monolithic design systems couple all design functions to a single model, resulting in limitations such as limited context windows, concentrated cognitive load, and high risk of single-point failures. The fully centralized multi-agent organizational model suffers from communication bottlenecks and single-point failure risks, while the fully decentralized organizational model makes it difficult to achieve global quality control. Agent capabilities are coupled to specific task prompts and cannot be reused and reorganized as standardized capability units, requiring overall reconstruction when the system expands to new professional functions.

[0008] In summary, existing technologies lack a distributed design system for building layout that features atomic encapsulation of agent capabilities, structured knowledge support, decoupling of agent collaboration with traceability, and embedding of user professional judgment into the execution loop. Summary of the Invention

[0009] To address the shortcomings of existing technologies, this invention proposes a distributed design system for architectural layout through multi-agent collaboration. This system encapsulates the professional capabilities of each agent involved in architectural layout design in an atomic manner, making them reusable and combinable. It provides structured and highly accurate knowledge retrieval support for knowledge-intensive design tasks, decouples collaborative communication between agents and ensures full traceability, and allows users' professional judgments to be embedded in the automated design execution loop. This overcomes the technical problems of existing monolithic design systems and general multi-agent frameworks, such as unreusable capability coupling, insufficient knowledge support, long-chain reasoning context bloat, black-box collaborative processes, and broken human-machine collaboration.

[0010] It should be noted that this invention addresses the organization and construction of architectural layout design systems at the systems engineering level, rather than the problem of the planar layout generation algorithm itself. The layout generation tools called by each Agent service node in this invention can adopt various existing layout generation methods. The contribution of this invention lies in providing atomic Agent capability encapsulation, structured knowledge service support, and decoupled, traceable, distributed collaborative infrastructure for these generation capabilities.

[0011] This invention provides a distributed architectural layout design system with multi-agent collaboration, comprising a distributed agent service layer, a knowledge service layer, a collaborative middleware layer, and a human-computer interaction layer. The distributed agent service layer includes multiple agent service nodes that are independently deployed and categorized according to architectural design professional functions.

[0012] Each Agent service node comprises a general capability unit and a role-specialized unit. The general capability unit serves as a reusable capability foundation independent of role, including a hierarchical planning module, a multi-level memory management module, and a tool integration module. The hierarchical planning module, with its two-layer structure of planning and step layers, explicitly breaks down complex design tasks into observable and controllable ordered sequences of steps, driving the Agent to operate stably in a cycle of planning, execution, and reflection. The multi-level memory management module, with its three-tier structure of perceptual memory, short-term memory, and long-term memory, handles transient high-density input, inference trajectories within the task cycle, and cross-task historical experience, respectively, suppressing context inflation in long-chain inference. The tool integration module integrates various tools using a unified interface specification, transforming the Agent's reasoning capabilities into actual actions. The role-specialized unit records the Agent service node's role positioning, core objectives, dedicated toolset, standard operating procedures, and deliverable specifications, making each Agent service node a specialized design entity with clearly defined responsibilities and predictable behavior.

[0013] Preferably, the knowledge service layer includes a knowledge base module and a knowledge graph module. The knowledge base module adopts a dual-path storage architecture combining vector storage and keyword indexing, and is connected to a hybrid retrieval module: on the input side, multi-source heterogeneous architectural knowledge documents are structurally parsed, divided into blocks according to original chapters, and then vectorized encoding and keyword extraction are performed respectively, with vector results and keyword results stored separately; on the query side, the hybrid retrieval module performs vector semantic retrieval and keyword precise retrieval in parallel, and returns retrieval results carrying traceability information after text inclusion relation deduplication and semantic similarity reordering. The knowledge graph module stores entities in the architectural field, relationships between entities, and hierarchical community structures, and is connected to a multi-level graph retrieval module: entities and relationships are extracted through a large language model to construct a global graph, and communities are divided using the Leiden algorithm and modeled as high-order nodes to form a hierarchical community structure; the multi-level graph retrieval module provides four types of operations: node neighbor query, node community affiliation query, community content query, and community level query, and supports multi-granularity knowledge reasoning from micro-entities to macro-communities according to a three-stage strategy of positioning, exploration, and in-depth. The knowledge service layer provides continuous professional knowledge support to each Agent service node in the form of retrieval services.

[0014] Preferably, the collaborative middleware layer includes a structured communication protocol module, a publish-subscribe module, a message pool module, and a shared workspace module. No direct point-to-point communication is established between the agent service nodes; instead, message interaction and design file sharing are decoupled through the collaborative middleware layer. The structured communication protocol module defines a unified message field format, constraining the input and output behavior of each node. The publish-subscribe module actively pushes information to the working memory of the subscribing nodes according to the message topic. The message pool module maintains a time-series message queue, carrying all task output summaries and interactive messages, and supports multi-dimensional combined retrieval. The shared workspace module carries all intermediate products and final deliverables in the design process in the form of a shared file system.

[0015] Preferably, the human-computer interaction layer is connected to the distributed Agent service layer, which is used to receive design tasks and feedback submitted by users and forward them to Agent service nodes, and present the output of each stage to users for review in a structured form, so that the architect's professional judgment is directly embedded in the design execution cycle.

[0016] Compared with the prior art, the present invention has at least the following beneficial effects: 1. This invention, through a two-layer encapsulation of general capability units and role-specific units, atomizes the professional capabilities of each Agent into service nodes with clearly defined responsibilities, standardized interfaces, and independent deployment capabilities. Specifically, the hierarchical planning module makes task decomposition explicitly observable, while the multi-level memory management module isolates transient high-density information in the perceptual memory layer and supports dynamic cleanup, compressing and solidifying only key experiences into the long-term memory layer. This suppresses context expansion in long-chain reasoning from the source of information organization, enabling the Agent to maintain stable reasoning capabilities in complex reasoning tasks. In a preferred embodiment of this invention, on a Level 3 complex canonical reasoning task, the canonical analyst Agent service node using the atomic capability encapsulation of this invention achieves an F1 score of 0.65, while the general Agent with the same underlying model, due to context expansion caused by the accumulation of a large amount of unstructured text in multiple rounds of retrieval, experiences a sharp drop in F1 score to 0.38, verifying the role of atomic capability encapsulation in ensuring reasoning stability.

[0017] 2. This invention provides structured knowledge support for knowledge-intensive design tasks through the synergistic effect of a knowledge base module and a knowledge graph module. The hybrid retrieval module uses vector semantic recall to capture the deep semantic relationship between queries and knowledge, and keyword precision recall to ensure accurate text location. These two modules are integrated through deduplication and reordering, fully leveraging the complementarity of semantic matching and lexical matching retrieval mechanisms. The knowledge graph module organizes normative texts into entity, relation, and hierarchical community structures, supporting multi-hop reasoning and multi-granularity knowledge navigation, returning highly condensed structured knowledge rather than lengthy text, ensuring information integrity while controlling context length. In a preferred embodiment of this invention, the overall F1 score for normative analysis tasks reaches 0.79 to 0.80, an improvement of approximately 19.9% ​​compared to the 0.66 of the naive retrieval enhancement generation method, and an improvement of over 160% compared to the 0.30 directly output by a large language model. Ablation experiments further demonstrate that removing knowledge base retrieval or knowledge graph retrieval results in performance losses of 9.8% and 8.2%, respectively. The two are functionally orthogonal and complementary; neither path can be replaced by the other.

[0018] 3. This invention achieves decoupled message interaction between Agent service nodes through a collaborative middleware layer. The structured communication protocol module constrains node input and output with predefined message formats, eliminating the loose and ambiguous information problems of unconstrained natural language communication; the publish-subscribe module actively pushes dependency information through topic subscription, avoiding the omission of receivers in point-to-point communication; the message pool module archives all interactive messages with a time-series queue and supports combined retrieval, condensing the entire information flow of the collaborative process into searchable structured records, making the entire design process traceable and auditable, and enabling each Agent service node to review its own tasks from a global perspective and make more informed decisions.

[0019] 4. In this invention, each Agent service node is deployed independently, and the underlying large language model of each node can be configured differently according to its function. For example, the layout design node with high requirements for spatial geometric reasoning is configured with a model with strong spatial reasoning ability, while the other nodes are configured with a general model. This makes the system's computing resources and model capabilities accurately matched according to function, avoiding the capability mismatch of "one model for all" in monolithic architecture. At the same time, the failure or replacement of any node does not affect the operation of other nodes, eliminating the risk of single point of failure. The system can flexibly expand and reorganize its functions by adding, removing or replacing Agent service nodes, and has reusability and composability. Attached Figure Description

[0020] Figure 1 This is a system framework diagram of a distributed design system for multi-agent collaborative building layout according to the present invention; Figure 2 This is a schematic diagram of the atomic capability structure of the Agent service node of the present invention; Figure 3 This is a schematic diagram of the multi-level memory management mechanism of the present invention; Figure 4 This is a schematic diagram illustrating the knowledge base construction and hybrid retrieval process of the present invention; Figure 5 This is a schematic diagram illustrating the knowledge graph construction and multi-level retrieval process of the present invention; Figure 6 This is a schematic diagram illustrating the composition and message flow of the collaborative middleware layer of the present invention; Figure 7 This is a schematic diagram of the human-computer interaction framework of the present invention; Figure 8 This is a comparison chart of the experimental results of the standard analytical capability of this invention; Figure 9 The figure shows the experimental results of system-level ablation according to the present invention. Detailed Implementation

[0021] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0022] In the description of this invention, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of the stated features. In the description of this invention, "a plurality of" means two or more, unless otherwise explicitly specified.

[0023] In the description of this invention, the term "for example" is used to mean "used as an example, illustration, or description." Any embodiment described as "for example" in this invention is not necessarily to be construed as being more preferred or advantageous than other embodiments. The following description is provided to enable any person skilled in the art to make and use the invention. Details are set forth in the following description for purposes of explanation. It should be understood that those skilled in the art will recognize that the invention can be made without using these specific details. In other instances, well-known structures and processes will not be described in detail to avoid obscuring the description of the invention with unnecessary detail. Therefore, the invention is not intended to be limited to the embodiments shown, but is consistent with the broadest scope of the principles and features disclosed herein.

[0024] Example 1 like Figure 1As shown, the distributed design system for building layout with multi-agent collaboration in this embodiment includes: a distributed agent service layer, a knowledge service layer, a collaborative middleware layer, and a human-computer interaction layer.

[0025] The distributed agent service layer comprises multiple agent service nodes categorized according to architectural design professional functions. In this embodiment, through a systematic decomposition of professional division of labor and role positioning in architectural design practice, seven agent service nodes are set up: Project Management Agent Service Node, Site Analyst Agent Service Node, Standard Analyst Agent Service Node, Case Analyst Agent Service Node, Chief Architect Agent Service Node, Layout Architect Agent Service Node, and Design Expression Agent Service Node. Each agent service node is deployed independently, and can be deployed on different processes or different physical computing nodes of the same server. The underlying large language model of each node is configured differently according to its function. In this embodiment, considering the high requirements of spatial geometric reasoning tasks for model spatial understanding capabilities, the Layout Architect Agent Service Node uses the claude-sonnet-4-5 model as its underlying model, while the other six agent service nodes uniformly use the doubao-seed-1-6-251015 model as their underlying model. The temperature parameter of each node is set to 0.3, and the maximum number of reasoning iterations is set to 10 rounds.

[0026] The knowledge service layer is the main knowledge support layer of the system, deployed independently of each Agent service node. It includes a knowledge base module and a knowledge graph module, responding to knowledge access requests from each Agent service node in the form of a retrieval service. The collaboration middleware layer includes a structured communication protocol module, a publish / subscribe module, a message pool module, and a shared workspace module. Agent service nodes do not establish direct point-to-point communication; all message interaction and file sharing are completed through the collaboration middleware layer. The human-computer interaction layer is user-facing and consists of a dialogue module, an execution tracking module, and a workspace module, responsible for task access, process presentation, and review feedback.

[0027] The human-computer interaction layer is bidirectionally connected to the distributed agent service layer, the distributed agent service layer is bidirectionally connected to the collaborative middleware layer, the distributed agent service layer is connected to the knowledge service layer through a retrieval service interface, and the knowledge service layer continuously obtains knowledge raw materials from external data sources, including building code documents, building case libraries, map services, and open network data.

[0028] Distributed Agent Service Layer like Figure 2 As shown, each Agent service node Ai consists of two parts: a general capability unit and a role-specialized unit. Its complete definition can be formally expressed as: Ai =<Ri,Gi,Ti,Φi,Di> , Here, Ri represents the role positioning, defining the professional responsibilities of the Agent service node within the team; Gi represents the core objective, clarifying its work goals and result requirements; Ti represents the dedicated toolset, i.e., the set of dedicated functional modules provided for it; Φi represents the Standard Operating Procedure (SOP), i.e., the standardized workflow; and Di represents the deliverable specification, i.e., the structured output format requirements. The role specialization unit is implemented by writing the above five tuples into the node's system prompts, ensuring the consistency and predictability of the Agent service node's behavior.

[0029] General Capability Unit The general ability unit is a reusable ability base that is independent of roles. It is based on the reasoning-action mechanism and includes a hierarchical planning module, a multi-level memory management module, and a tool integration module.

[0030] Hierarchical Planning Module. Unlike implicit thought chain reasoning, the hierarchical planning module requires Agent service nodes to explicitly present the task decomposition scheme in a structured form, making the reasoning process observable and controllable. The planning system adopts a two-layer structure: a planning layer and a step layer. The planning layer defines the task as an ordered sequence of steps P =<s1,s2,…,sn> In the step layer, each step si = (descriptioni, statusi, resultti), where descriptioni describes the step's objective, statusi ∈ {pending, active, completed, failed} represents the execution status (pending, in progress, completed, and failed), and resultti stores the summary conclusion upon step completion. The hierarchical planning module provides a complete plan lifecycle management interface through planning tools, including plan creation, step progression (next_step), plan update, activation switching (set_active), and plan deletion operations. The execution flow of the Agent service node follows a cycle of planning, execution, and reflection: Create(P) → Execute(si) → Reflect(resulti) → NextStep(si+1), i.e., creating a plan, executing the current step, reflecting on the step's conclusion, and progressing to the next step. When a node determines that the current step is complete, it calls the step progression operation and submits the step's conclusion; the system automatically updates the step status and activates the next step. This mechanism enables Agent service nodes not only to reason and act but also to explicitly track their own task progress.

[0031] Multi-level memory management module. For example... Figure 3As shown, in response to the challenges of diverse information sources, long reasoning chains, and limited context windows in architectural layout design tasks, the multi-level memory management module adopts a three-level memory architecture that draws inspiration from the memory model of the human cognitive system.

[0032] The perceptual memory layer is responsible for storing the intensive data context returned by tool calls. This mainly includes image data, large-scale knowledge retrieval results, and other content that occupies a large amount of context space but is only needed in specific reasoning steps. Its formal definition is Msensory = {mi | mi = Output(tj), tj ∈ Tsensory}, where Tsensory is the set of tools that trigger perceptual memory storage, such as knowledge base retrieval, knowledge graph query, and image viewing tools, and Output(tj) is the return result of tool tj. The perceptual memory cleanup authority is granted to the Agent service node itself, which dynamically cleans up irrelevant perceptual information based on task progress, context pressure, and information relevance.

[0033] The short-term memory layer maintains the complete reasoning trajectory within the current task cycle, stores the task requirements of the user or upstream agent service nodes, and the thought processes, tool call records, and intermediate decisions generated during multiple rounds of reasoning interactions. Its formal definition is Mshort = {<a1,o1> ,<a2,o2> , ...,<an,on>} where ai represents the node action in the i-th round, including reasoning and tool invocation, and oi represents the corresponding observation result, including tool return or environmental feedback. When the task objective is achieved or clearly failed, the life cycle of short-term memory ends, and its key experience is extracted, compressed, and written into the long-term memory layer, while the specific reasoning details are discarded to save storage space, i.e., Mlong←Mlong∪Compress(Extract(Mshort)), where Extract(·) is the key experience extraction function, and Compress(·) is the summary compression and structured representation function.

[0034] The long-term memory layer stores cross-task knowledge, including the execution process, results, and related experience of historical tasks. It employs vectorized indexing and semantic retrieval mechanisms to support nodes in quickly accessing relevant historical experience when a new task starts. The retrieval process is defined as Mlong(q, k) = TopKm∈Mlong(sim(q, emb(m)), k), where q is the current task context query, emb(·) is the semantic embedding function, sim(·, ·) is the similarity measure, and TopK(·, k) represents the return of the k most similar historical experiences. The perceptual memory layer processes the transient information of high-dimensional input, the short-term memory layer maintains the continuity of task execution, and the long-term memory layer accumulates task experience throughout the node's lifecycle. These three layers have clear divisions of labor and cooperate with each other to jointly support the Agent service node's continuous reasoning ability in complex tasks.

[0035] Tool Integration Module. The tool system serves as a bridge for Agent service nodes to translate reasoning capabilities into practical actions. The tool integration module employs a unified interface specification for each integrated tool. Each tool declares its name, description, and parameters, which are then converted into structured data format for tool context registration. Agent service nodes select and invoke tools through a function call mechanism: at = LLM(Contextt, T) →<tooli,argsi> Where T represents the available toolset, Contextt represents the node context information at time t, at represents the action at time t, LLM(·) is the inference function of the underlying large language model, and tooli and argsi are the selected tool and its calling parameters, respectively. After the tool executes, it feeds back the result to the node, updates the context, and triggers the next round of inference: Contextt+1=Contextt⊕<at,ot> , where ot = tooli(argsi) is the observation returned by the tool execution, and ⊕ represents the operation of appending the action-observation pair to the context.

[0036] Role Specialization Unit The role specialization unit records the differentiated role positioning Ri, core objective Gi, exclusive toolset Ti, standard operating procedure Φi, and deliverable specification Di for each Agent service node. In this embodiment, the roles and core objectives of the seven Agent service nodes are configured as follows: Project Management Agent Service Node, with the role of project management expert and core objectives of requirement understanding, structured task decomposition, progress tracking, and risk control; Site Analyst Agent Service Node, with the role of site analysis expert and core objectives of multi-dimensional analysis of site physical environment, accessibility, and cultural history; Standard Analyst Agent Service Node, with the role of standard retrieval expert and core objectives of extracting structured technical indicators and design constraints from the standard knowledge graph; Case Analyst Agent Service Node, with the role of case study expert and core objectives of retrieval and strategy extraction analysis of precedent cases for design problems; Chief Architect Agent Service Node, with the role of design decision expert and core objectives of integrating preliminary analysis data and developing conceptual design briefs and strategy reports; Layout Architect Agent Service Node, with the role of floor plan expert and core objectives of transforming complex constraints into detailed architectural floor plan layout schemes that comply with standards; and Design Expression Agent Service Node, with the role of deliverables expert and core objectives of drawing optimization and final design document integration and output.

[0037] In terms of tool configuration, the tool integration module divides all system tools into four categories according to function: the general toolset TGeneral, which provides basic capabilities such as planning, memory management, and loop termination, as well as general network tools such as web search, web browsing, resource download, and image viewing. It is a public toolset accessible to all nodes; the research toolset TResearch, which serves information acquisition and knowledge retrieval in the early stages of design, including normative research tools such as knowledge base retrieval tools, knowledge graph retrieval tools, and normative network retrieval tools, forming a complete retrieval chain from structured knowledge to unstructured text, case study tools such as case library search tools and online architectural case website search tools, and site research tools such as static map acquisition tools, geocoding tools, and POI search tools; the design toolset TDesign, which provides professional calculation and generation capabilities such as spatial relationship reasoning tools, data-driven layout generation tools, reasoning-driven layout generation tools, and image generation and enhancement tools; and the team toolset TTeamwork, which supports multi-node collaborative work mechanisms, including task sending tools, task summary tools, task management tools, and work environment editor tools. Each Agent service node, based on its own role and task boundaries, combines the above four tool sets as needed to form a differentiated, exclusive toolset Ti: Project Management nodes are configured with task management and task assignment tools; Site Analyst nodes are configured with map acquisition, geocoding, POI search, and web download tools; Standards Analyst nodes are configured with knowledge base retrieval, knowledge graph retrieval, standards web retrieval, case library search, and web download tools; Case Analyst nodes are configured with case library search, online case website search, and web download tools; Chief Architect nodes are configured with spatial relationship, knowledge graph retrieval, and task assignment tools; Layout Architect nodes are configured with spatial relationship, reasoning-driven layout generation, and data-driven layout generation tools; Design Expression nodes are configured with graph generation tools; and all nodes share a common collaboration tool.

[0038] Regarding standard operating procedures (SOPs), each Agent service node follows four standardized phases within the general SOP framework: Context retrieval phase: The node extracts team messages from the message pool, including user requirement descriptions and task progress for each member, and retrieves relevant context from the shared workspace using the work environment editor tool based on its relevance to the current task; Task planning phase: The node semantically parses the upstream task description into task objectives, constraints, and input data, and formulates a structured execution plan using the hierarchical planning module; Iterative execution phase: The node executes sub-tasks step-by-step according to the plan, selecting and calling appropriate tools from its dedicated toolset. During this phase, intermediate products can be output through the work environment editor tool, and perceptual memories can be cleared using the memory management tool; Reflection and delivery phase: Before task delivery, the node critically reviews the execution process and results, packages the verified results into standardized deliverables according to the deliverable specification Di, submits them to the shared workspace, and submits a work summary and deliverable index to the message pool using the task summary tool. In addition to the general SOP, each node also customizes its own specialized SOPs and deliverable specifications.

[0039] Knowledge Service Layer Architectural layout design is a typical knowledge-intensive task. The knowledge service layer provides continuous professional knowledge support for each agent service node, including two major engines: the knowledge base module and the knowledge graph module.

[0040] (a) Knowledge Base Module The knowledge base module adopts a dual-path storage architecture combining vector storage and keyword indexing, including a text knowledge base and an image case knowledge base. Its construction process is as follows: Figure 4 The left half is shown.

[0041] The construction of the text knowledge base includes four stages: data processing, knowledge segmentation, vectorization and keyword extraction, and knowledge storage. In the data processing stage, differentiated preprocessing strategies are adopted for different types of data sources: PDF technical documents are structured and converted to Markdown format, preserving semantic hierarchy and layout information, using open-source parsing tools; Word documents are also converted to a unified Markdown format after extracting text content, table structure, and style annotations; web page data is filtered through HTML parsing to remove navigation bars, advertisements, and other noisy elements, extracting the main text content and preserving semantic tags. In the knowledge segmentation stage, the original chapter structure of the document is followed, with heading levels as the dividing criteria to ensure the semantic integrity of each text block. Each text block ci = {texti, sourcei, sectioni}, where texti is the text content, sourcei is the document source identifier, and sectioni is the path to the corresponding chapter; tables and images in the document are extracted as independent text blocks, with tables stored in Markdown table format and images recorded as path references. The vectorization and keyword extraction stages perform two encodings simultaneously on each text block: Vectorization uses a vector embedding model to embed the text block vi = Embed(ci.text) ∈ Rd, where vi is the vector representation of text block ci, d is the embedding dimension, and Embed(·) is the encoding function of the embedding model; Keyword extraction uses the KeyBERT framework combined with a multilingual pre-trained model, leveraging its context awareness capabilities to identify keywords by calculating the semantic similarity between candidate words and the overall document, score(wj, ci) = sim(Embed(wj), Embed(ci)), where wj is the candidate keyword. The knowledge storage stage constructs a dual-path storage system: the semantic retrieval path stores vectorized text blocks based on the Milvus vector database, using the HNSW indexing algorithm, with each record containing triples.<vi,texti,sourcei> It supports approximate nearest neighbor retrieval based on cosine similarity sim(q, vi) = q·vi / (‖q‖‖vi‖), where q is the query vector; the keyword retrieval path stores text blocks and keyword groups in the Elasticsearch database, with each record including triples.<keywordsi,texti,sourcei> It utilizes an inverted index mechanism to achieve efficient full-text search and fuzzy matching.

[0042] The construction of the image case knowledge base addresses the problem that architectural case images carry rich implicit design knowledge, but their unstructured form makes them difficult to retrieve directly. It introduces a visual-language model to convert images into searchable structured text descriptions: Images extracted from PDF documents, crawled from web pages, and native image files are uniformly uploaded to an image server to obtain a unified address; the image address is input into the visual-language model, and a prompt-guided engineering model generates standardized image metadata {name, description} = VLM(image_url, prompt), including the image name and description, where VLM(·) is the visual-language model, image_url is the image address, and prompt is the prompt word; the generated descriptive text then undergoes a vectorization and keyword extraction process similar to that of textual knowledge, and the image address is stored in the case vector library and case index library respectively.

[0043] (ii) Hybrid Search Module The hybrid retrieval module employs a hybrid retrieval mechanism based on multi-path recall and re-ranking, fully leveraging the semantic matching capabilities of vector retrieval and the precise positioning advantages of keyword retrieval. Its process is as follows: Figure 4 The right half is shown. For query requests from Agent service nodes, the system initiates two independent recall paths in parallel: the vector semantic recall path performs semantic similarity matching based on a vector database, encodes the query text into a query vector q = Embed(query) ∈ Rd using the same embedding model as the input data, and then retrieves the kv most similar text blocks to q in the vector space: Dv = TopKkv({ci | sim(q, vi)} Ni = 1), where N is the total number of text blocks in the knowledge base, and TopKkv(·) returns the kv candidates with the highest similarity. The keyword precise recall path performs lexical matching based on the Elasticsearch inverted index, receives a pre-extracted set of query keywords, and performs a Boolean search: Dk = TopKkk({ci | ∨mj = 1(kwj ∈ ci.keywords)}), where ∨ represents a logical OR operation, kwj is the j-th query keyword, m is the number of keywords, kk is the upper limit of the number of keywords recalled, and the BM25 scoring algorithm sorts the matching results based on term frequency and inverse document frequency.

[0044] The result sets Dv and Dk of the two-way recall may overlap. The hybrid retrieval module first performs deduplication on the recall results based on text inclusion relations: for any two text blocks ci and cj in the candidate set D = Dv ∪ Dk, if ci.text cj.text or cj.text For `ci.text`, the longer text is retained while redundant substrings are removed. The deduplicated candidate set is then optimized through a re-ranking mechanism: the semantic similarity score between each candidate block `c′i` and the query vector is recalculated as `score(c′i) = sim(q, Embed(c′i.text))`, and the blocks are sorted in descending order of similarity score. The top K text blocks are selected as the final retrieval result, `R = TopKK({c′i | score(c′i)})`. This two-stage retrieval architecture, coarse-fine ranking, ensures recall coverage while prioritizing the most relevant knowledge through refined semantic matching. In the retrieval results returned to the Agent service node, each knowledge unit contains a triplet `ri = {texti, sourcei, sectioni}`, preserving the source information of the knowledge for subsequent credibility assessment and citation annotation.

[0045] (III) Knowledge Graph Module Knowledge base retrieval focuses on content matching and struggles to support reasoning about relationships between entities. The knowledge graph module captures entity relationships and community structure within architectural knowledge; its construction process is as follows: Figure 5 The left half shows three core steps: entity relationship extraction, community detection and hierarchical aggregation, and graph database storage.

[0046] In the entity-relation extraction step, for each text block ci, a large language model is used to extract entities and relations Ei, Ri = LLMextract(ci.text), where Ei = {e1, e2, ..., en} is the set of extracted entities, and each entity ej = (classj, namej, descriptionj, infoj) contains four types of attributes: entity category, entity name, entity description, and additional structured information; Ri = {r1, r2, ..., rm} is the set of extracted relations, and each relation is represented as a triple (esj, rj, etj), where esj and etj are the source entity and the target entity, respectively, and the relation rj = (typej, strengthj, infoj) contains three types of attributes: relation type, relation strength, and context description. After merging and deduplicating the entities and relations extracted from all text blocks, a global knowledge graph G = (V, R) is constructed, where the vertex set V = ∪iEi and the edge set R = ∪iRi.

[0047] The community detection and hierarchical aggregation steps draw on the hierarchical indexing concept of GraphRAG (referencing the GraphRAG framework proposed by Edge et al.: From Local to Global: A Graph RAG Approach to Query-Focused Summarization, arXiv preprint platform, 2024, Edge D), and use the Leiden algorithm to partition the global graph into communities. The Leiden algorithm identifies tightly connected entity clusters by optimizing the modularity function: Q = 1 / (2m)·Σi,j[Aij-kikj / (2m)]δ(ci,cj), where Aij is the adjacency matrix element, ki is the degree of node i, m is the total number of edges, ci is the community to which node i belongs, and δ(·,·) is the Kronecker delta function; the algorithm iteratively optimizes the local modularity until it converges to a stable community partition. The detected communities C = {C1, C2, …, Ck} represent semantic clusters in the graph, and each community corresponds to a specific topic domain. To achieve a hierarchical graph structure, the system models communities as high-order nodes in the graph: First, for each community Cj, a large language model is used to generate the community name, summary, and details, finding {namej, summaryj, findingsj} = LLMsummarize(Cj), and then this is added to the graph as a new node. Next, the Leiden algorithm is used for multi-level iteration to construct the community hierarchy. For each entity node ei∈Cj in community Cj, a belonging edge (cj, rcontains, ei) is added, and for parent and child communities generated during the iteration, hierarchical edges (cparent, rsubsumes, cchild) are added. This design transforms communities from abstract partitioning results into queryable graph entities, enabling the graph to support both atomic-level entity retrieval and topic-level community retrieval. The graph database storage step uses the Neo4j graph database, leveraging its native graph storage engine to achieve efficient path querying and subgraph matching.

[0048] (iv) Multi-level map retrieval module The multi-level graph retrieval module is designed based on graph databases and features four core retrieval operations, constructing a multi-level query mechanism from micro-entities to macro-communities, such as... Figure 5 The right half is shown. The node neighbor query `find_node_neighbors` is used to explore the local relational network of entities: given node names and optional community constraints, it retrieves the starting node `e0`, community nodes `cj`, and their member node set `Vcj`. A breadth-first search strategy is used to traverse the graph at a maximum depth of `dmax`: N(e0, dmax, Vcj) = {(e, d) | e ∈ BFS(e0, dmax) ∧ (Vcj = ...}}} ∨e∈Vcj)}, where BFS(·) is the breadth-first search function and d is the node depth. The node community affiliation query find_communities_of_node is used to quickly locate the position of an entity in a hierarchical community structure: by traversing edges of type contains, all communities to which the target node e belongs are obtained: C(e)={c|(e,rcontains,c)∈E}. The query results are sorted by community level, forming a community sequence from fine-grained to coarse-grained. For example, the "fire door" node belongs to the "fireproof component" community, the "fire compartment" community, and the "fire protection code" community. The `find_child_nodes_of_community` query is used to expand the internal structure of a specific community: it retrieves all member nodes Vcj = {e | (cj, rcontains, e) ∈ E} contained in the target community and the relationships between member nodes Ecj = {(es, r, et) | es, et ∈ Vcj ∧ (es, r, et) ∈ E}, suitable for topic exploration scenarios; for example, when a node needs a comprehensive understanding of the "operating room" community, it can obtain all relevant equipment types, size requirements, and design specifications at once. The `get_community_tree` query is used to explore the inclusion and refinement relationships between communities: it traces the parent community Cparent(cj) = {c | (c, rsubsumes, cj) ∈ E} and child community Cchild(cj) = {c | (cj, rsubsumes, c) ∈ E} through hierarchical edges, forming a local tree structure rooted at the target community.

[0049] Building upon the four types of operations described above, the multi-level graph retrieval module employs a three-stage retrieval strategy: The first stage, global positioning, uses node community affiliation queries to quickly locate target entities and their positions within a hierarchical community structure based on keywords, outputting basic node attributes and community affiliation at each level. The second stage, scope exploration, utilizes node neighbor queries to specify communities and perform local graph traversal under community constraints if the focus is on the overall knowledge of a topic; otherwise, it uses community content queries to obtain a panoramic view of all nodes and relationships within a community. The third stage, structural in-depth exploration, uses community hierarchy queries to trace the parent-child structure of communities, revealing the abstract-concrete hierarchical chain of knowledge. This strategy elevates graph retrieval from a single-point query to a systematic knowledge exploration process, enabling Agent service nodes to efficiently locate, flexibly navigate, and deeply mine relevant knowledge within massive graphs.

[0050] Collaborative Middleware Layer like Figure 6As shown, the collaborative middleware layer includes a structured communication protocol module, a publish / subscribe module, a message pool module, and a shared workspace module, ensuring accurate information transmission, effective knowledge sharing, and traceability of the collaborative process.

[0051] The structured communication protocol module addresses the problems of loose information structure, missing key elements, parsing difficulties, and high ambiguity in unconstrained natural language communication. This module uses predefined message format specifications to constrain the input and output behavior of each Agent service node. All inter-node communication messages M follow a unified six-field structure: M = (timestamp, type, sender, recipient, content, refs), where timestamp is the message timestamp, type ∈ {task, result, notify} is the message type (task distribution message, task result return message, and status notification message), sender is the sender node identifier, recipient is the receiver node identifier (can be empty to indicate broadcast), content is the message body, and refs are references to associated workspace files. When a project management Agent service node distributes a task, it constructs a task distribution message Mtask = (time, task, PM, recipient, {task_id, task_desc}, ... The task_id is the unique identifier of the task, and the task_desc describes the core task content and expected deliverables. This format is encapsulated by the task sending tool. After the execution node completes the task, it constructs a task result return message Mresult = (tnow, result, Asender, PM, {task_id, status, summary}, refs), where status ∈ {completed, partial, failed} indicates the task completion status, i.e., completed, partially completed, and failed. summary is a structured summary of the task conclusions, and refs are file references of the deliverables in the workspace. This format is encapsulated by the task summary tool.

[0052] Publish / Subscribe Module. In complex collaborative scenarios, the tasks of some nodes are heavily dependent on the task results of upstream nodes. Traditional point-to-point communication requires explicitly specifying each receiver, increasing communication complexity and potentially leading to information loss. The publish / subscribe module enables proactive information push and selective reception: Let the set of message topics in the system be Θ = {θ1, θ2, ..., θm}, and the subscription set of the Agent service node Ai be Θi. Θ, each node configures its subscribed message topics according to its own task requirements; when any node publishes a message M with topic θj, the system automatically distributes the message to all subscribed nodes that satisfy θj∈Θi, i.e. Ai:θj∈Θi M∈Memory(Ai), where Memory(Ai) represents the working memory of node Ai. Subscribed messages are directly injected into the node's working memory without the node needing to actively query it, thus increasing the node's focus on task dependency information.

[0053] The message pool module is the information hub of the collaboration mechanism. It carries the task output summaries and interaction messages of all nodes and maintains a time-series message queue P = {M1, M2, ..., MN} ordered by timestamps. All messages follow a six-field structure definition. For write operations, node messages output using a standardized protocol are assigned a globally unique timestamp and written to the message pool Publish(Ai, M): P←P∪{M} after specifying the message topic according to the sender configuration. For read operations, nodes can retrieve relevant messages from the message pool through a query interface. The query operation supports combined condition queries Query(Q): R←{Mk∈P|Match(Mk, Q)}, where Q is the query condition, such as {type=result, sender=Ai, θ=design}, i.e., a combination of message type, sender, and topic; Match(·) is the matching function; and R is the query result set. Query conditions support any combination of time range, message type, sender identifier, and message topic tag. Through a globally shared message pool, nodes can transparently obtain messages from other roles without needing to query and wait for a response point-to-point. This allows them to examine their own tasks from a global perspective and make more informed decisions.

[0054] The shared workspace module includes intermediate deliverables such as analysis data, process drawings, and review comments, as well as final deliverables such as layout drawings and design documents. All Agent service nodes can perform file operations such as saving, reading, updating, deleting, and listing on the workspace through a unified environment editor tool, achieving complete sharing of the design context; the workspace organizes all working files in a file tree format, supporting concurrent read and write operations.

[0055] Human-computer interaction layer like Figure 7As shown, the human-computer interaction layer includes a dialogue module, an execution tracking module, and a workspace module. The dialogue module allows users to initiate design tasks or input feedback via natural language, and, when necessary, simultaneously upload reference documents such as the site master plan and task specifications as initial input, while retaining the complete interaction context in historical records. The execution tracking module presents the execution steps and tool call details of each Agent service node in real time, allowing users to progressively view the reasoning process and intermediate outputs of each step. The workspace module archives all working files produced by each node in a file tree format. These three modules work together to support the entire process of task assignment, process tracking, and result review: After each stage of the task is completed, the project management Agent service node presents the stage outputs in the shared workspace to the user in a structured format, allowing the user to choose to continue or provide modification suggestions for specific issues; the project management Agent service node then re-arranges the task instructions and distributes them to the corresponding nodes via a message pool, restarting the local process. This mechanism effectively prevents single-stage deviations from cascading and amplifying into subsequent stages, ensuring that the final solution consistently meets the design intent.

[0056] The human-computer interaction layer and the project management agent service nodes in the distributed agent service layer are bidirectionally connected: downlink, user design tasks and feedback are transmitted; uplink, interim outputs and final results are transmitted. The distributed agent service layer and the collaboration middleware layer are fully interconnected: each agent service node accesses the message pool module and shared workspace module through the task sending tool, task summary tool, and work environment editor tool in the team toolset. All information flow between nodes is relayed through the collaboration middleware layer; there is no direct point-to-point link between any two agent service nodes. The distributed agent service layer and the knowledge service layer are connected through a retrieval service interface: each agent service node initiates queries to the knowledge service layer through the knowledge base retrieval tool and knowledge graph retrieval tool in the research toolset. The knowledge service layer returns structured knowledge carrying traceability information; the knowledge service layer connects to external data sources to continuously collect, process, and update knowledge.

[0057] User tasks enter the project management agent service node through the human-computer interaction layer. After being broken down into sub-tasks, they are distributed to the corresponding nodes via the message pool module in the form of task distribution messages. The site analyst, standard analyst, and case analyst nodes execute specialized analyses in parallel. During this process, they use the research toolset to call the knowledge service layer to obtain standard provisions, case references, and site data. The analysis products are stored on the shared workspace module and a completion notification is issued via the message pool module. After the analysis results are integrated, they are transmitted to the design nodes. The chief architect node conceives a conceptual scheme, and the layout architect node, under the dual constraints of the conceptual scheme and the constraint set, calls the layout generation tool in the design toolset to generate a specific layout scheme. Finally, the scheme is transformed into standard drawings and documents by the design expression node and delivered to the user through the human-computer interaction layer.

[0058] The system of this invention includes three types of feedback loops: First, micro-loops within nodes, driven by a hierarchical planning module; second, local iterative loops between design nodes, where the chief architect node reviews the layout scheme and generates modification suggestions, which are then fed back to the layout architect node to trigger the next iteration. This loop is transmitted through a collaborative middleware layer, eliminating the need for project management node intervention and reducing communication overhead; third, user review feedback loops, where user modifications to the phased outputs are rearranged by the human-computer interaction layer and project management nodes, triggering a local process restart. These three types of loops are nested layer by layer, jointly ensuring closed-loop control of design quality.

[0059] A collaborative process of retrieval, accumulation, and re-retrieval is formed between the knowledge service layer and the agent service nodes: In the downlink direction, the hybrid retrieval module and the multi-level graph retrieval module respond to node queries, returning condensed structured knowledge, which is directly injected into the node's working memory and perceptual memory; In the uplink direction, after each node completes its task, its deliverables are archived by the shared workspace module and can be used as new knowledge raw materials to be accumulated into the knowledge base through the parsing, segmentation, and vectorization process of the knowledge base module. Its key experiences are solidified into the long-term memory layer by the multi-level memory management module for retrieval and reuse in subsequent tasks, realizing the continuous accumulation and self-enhancement of system knowledge.

[0060] The message pool module works in conjunction with the multi-level memory management module: the publish-subscribe module directly injects subscribed messages into the node's working memory, ensuring the immediate availability of dependent information; historical messages in the message pool support combined retrieval, forming an external extension of the node's short-term memory; after the node's task is completed, key experiences in the short-term memory are compressed and solidified into the long-term memory layer, complementing the persistent archiving of the message pool to form a system-wide record that complements the node's internal memory.

[0061] Simulation Experiment (a) Knowledge Services and Atomic Ability Verification Experiments To verify the effectiveness of the knowledge service layer and atomic capability encapsulation in this system, a benchmark test set containing 30 specification query and analysis tasks was constructed. These tasks were divided into three levels based on complexity: L1 single-hop reasoning (directly querying a single specification clause), L2 multi-hop reasoning (comprehensive judgment involving multiple specification clauses), and L3 complex reasoning (multi-hop clause retrieval, logical reasoning, formula calculation, and cross-validation). Precision, recall, and F1 score were used as evaluation metrics. The specification analyst agent service node was compared with three baselines: a general agent, a naive retrieval enhancement generation method, and direct output from a large language model. All methods used the same underlying model and temperature parameters. Experimental results are as follows: Figure 8 As shown, the normative analyst agent service node achieved the best performance across all test samples, with an overall F1 score of 0.79, a 17.5% improvement compared to the general agent's 0.68, a 19.9% ​​improvement compared to the naive retrieval enhancement generation method's 0.66, and a 162.6% improvement compared to the direct output of the large language model's 0.30. Looking at different levels, on the L3 complex reasoning task, the normative analyst node maintained an F1 score of 0.65, while the general agent, due to the accumulation of a large amount of unstructured text in multiple rounds of retrieval leading to context inflation, experienced a sharp drop in F1 score to 0.38. This confirms the inhibitory effect of the multi-level memory management module in the atomic capability encapsulation of this invention on context inflation, and the advantage of the knowledge graph returning highly condensed structured knowledge while controlling context length and ensuring information integrity.

[0062] Further ablation experiments were conducted: disabling the keyword recall path reduced the F1 score to 0.77, disabling the vector semantic recall path reduced it to 0.75, completely removing knowledge base retrieval reduced it to 0.71, and completely removing knowledge graph retrieval reduced it to 0.73, with a complete node score of 0.80. The results indicate that vector semantic retrieval is the dominant path for knowledge base retrieval. The knowledge base and knowledge graph are functionally orthogonal and complementary, and neither path can be completely replaced by the other. In the L3 task, removing either the knowledge base or the knowledge graph resulted in an F1 score of 0.50, confirming the decisive role of the dual-engine knowledge service architecture for complex specification analysis tasks.

[0063] (II) System-level collaborative verification experiment A system-level benchmark suite was constructed for the complete layout design process, covering 15 standard test tasks in residential, hospital, and office building scenarios. These tasks were categorized into three levels of complexity, L1 to L3. Task materials included heterogeneous inputs such as fuzzy natural language requirement descriptions and site master plans. Functional indicators and regulatory references were automatically inferred and retrieved by the system. The final layout results were scored across five dimensions: site adaptability, regulatory compliance, indicator consistency, functional rationality, and circulation rationality. Comparison baselines included: direct generation from a large language model, a general single-agent system, a general multi-agent system, and a specialized single-agent system. Experimental results show that the overall average score of this system is 8.36, which is about 20.8% higher than the 6.92 score of the specialized single-agent system, about 72.4% higher than the 4.85 score of the general multi-agent system, about 126.6% higher than the 3.69 score of the general single-agent system, and more than 241% higher than the 2.45 score of the directly generated baseline. This gradient performance distribution indicates that the system performance gain is driven by the specialized role configuration and the distributed collaborative architecture of the multi-agent system.

[0064] Seven ablation variants were designed for each Agent service node in the system. A fixed injection strategy for intermediate products was adopted to eliminate upstream output fluctuation interference. Experimental results are as follows: Figure 9 As shown: Removing the project management node reduced the average score to 7.06, reflecting a systemic degradation in collaborative efficiency due to the lack of dynamic task scheduling; removing the specification analyst node caused the specification compliance score to plummet from 8.17 to 5.42, indicating that the internalized knowledge of the underlying model cannot replace the retrieval and textual source verification functions of the knowledge service layer; removing the chief architect node reduced the average score to 6.97, indicating a significant decline in functional and flow rationality; replacing the layout architect node with non-professional direct invocation resulted in a sharp drop in the average score to 5.06; removing the design expression node reduced the average score by 1.54. The performance degradation patterns of each node are highly consistent with their design positioning, quantitatively verifying the independent contribution and irreplaceability of each specialized agent service node as an atomic capability unit in this system. It should be noted that in the above embodiments, the descriptions of each embodiment have different focuses; for parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0065] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0066] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0067] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0068] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0069] Although preferred embodiments of the invention have been described, those skilled in the art, once they have learned the basic inventive concept, can make other changes and modifications to these embodiments.

[0070] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of this invention and its equivalents, this invention also intends to include these modifications and variations.

Claims

1. A distributed design system for building layout with multi-agent collaboration, characterized in that, include: The distributed Agent service layer includes multiple Agent service nodes that are divided according to architectural design professional functions and deployed independently. Each Agent service node includes a general capability unit and a role specialization unit. The general capability unit includes a hierarchical planning module, a multi-level memory management module, and a tool integration module. The role specialization unit records the role positioning, core objectives, exclusive toolset, standard operating procedures, and deliverable specifications. The knowledge service layer includes a knowledge base module that uses vector storage and keyword indexing for dual-path storage and connects to a hybrid retrieval module, and a knowledge graph module that stores entities in the construction field, relationships between entities, and hierarchical community structures and connects to a multi-level graph retrieval module. The collaborative middleware layer includes a structured communication protocol module, a publish-subscribe module, a message pool module, and a shared workspace module; the Agent service nodes do not establish direct point-to-point communication, but all message interaction and file sharing are decoupled through the collaborative middleware layer; The human-computer interaction layer is used to receive the user's design tasks and feedback and forward them to the Agent service layer.

2. The distributed design system for multi-agent collaborative building layout according to claim 1, characterized in that, The hierarchical planning module includes a planning layer and a step layer. The planning layer defines the tasks of the Agent service node as an ordered sequence of steps. In the step layer, each step records the step objective, execution status, and step conclusion. The execution status is one of four categories: pending execution, in execution, completed, and failed. The hierarchical planning module provides lifecycle management interfaces for plan creation, step advancement, plan update, activation switching, and plan deletion, driving the Agent service nodes to run in a cycle of planning, execution, and reflection: when the current step is determined to be completed, the step advancement interface is called to submit the step conclusion, automatically update the step status, and activate the next step.

3. The distributed design system for multi-agent collaborative building layout according to claim 1, characterized in that, The multi-level memory management module includes a perceptual memory layer, a short-term memory layer, and a long-term memory layer. The perception memory layer stores the intensive data context returned by the tool call, and the Agent service node to which it belongs dynamically cleans it up according to task progress, context pressure and information relevance. The short-term memory layer stores the thought process, tool call records and intermediate decisions generated by multiple rounds of reasoning within the current task cycle in the form of action-observation pair sequences. When the task objective is achieved or failed, the key experiences are extracted, compressed and written into the long-term memory layer, while the specific reasoning details are discarded. The long-term memory layer employs a vectorized indexing and semantic retrieval mechanism. When a new task starts, it retrieves the most similar historical experiences based on the current task context and injects them into the corresponding Agent service node.

4. The distributed design system for multi-agent collaborative building layout according to claim 1, characterized in that, The tool integration module adopts a unified interface specification for each integrated tool. Each tool declares its tool name, function description, and parameters and registers them as a tool context in a structured data format. The Agent service node selects a target tool from the available toolset based on the current context and generates invocation parameters. The tool execution result is used as an observation result and is added to the context along with the current invocation action to form an action-observation pair, triggering the next round of inference. The tools are divided into four categories according to their functions: general toolset, research toolset, design toolset, and team toolset. Each Agent service node's dedicated toolset is formed as needed from the four categories of toolsets based on its role.

5. The distributed design system for multi-agent collaborative building layout according to claim 1, characterized in that, The knowledge base module includes a text knowledge base and an image case knowledge base; The steps for constructing the text knowledge base include: The system performs structured parsing on multi-source heterogeneous documents and converts them into a unified format. It divides knowledge into blocks according to the original chapter structure of the documents, performs vectorization encoding and keyword extraction on each text block, and stores the vectorization results in a vector database and the keywords and text blocks in a keyword index database. The steps for constructing the image case knowledge base include: The case images are uploaded uniformly to obtain the image address. The visual-language model generates the image name and image description text. The image description text is vectorized and keywords are extracted, and then the image address is attached and stored in the vector database and keyword index database respectively.

6. The distributed design system for multi-agent collaborative building layout according to claim 1, characterized in that, The hybrid retrieval module initiates both a vector semantic recall path and a keyword precise recall path in parallel for each query request. The vector semantic recall path encodes the query text into a query vector and retrieves the text blocks with the highest similarity based on cosine similarity from the vector database. The keyword precise recall path performs a Boolean search in the keyword index database based on the query keyword set. The hybrid retrieval module performs deduplication processing on the union of the two recall results based on text inclusion relationships. For two text blocks with inclusion relationships, the longer text block is retained. The semantic similarity between each candidate text block and the query vector is recalculated and sorted in descending order of similarity. The top K text blocks are selected as the retrieval results and returned. Each retrieval result carries the text content, source document identifier, and source information of the chapter path to which it belongs.

7. A distributed design system for building layout with multi-agent collaboration according to claim 1, characterized in that, The construction steps of the knowledge graph module include: Entities and relations are extracted from each text block using a large language model. The entities include four types of attributes: entity category, entity name, entity description, and structured information. The relations are represented by a triple of source entity, relation, and target entity and include three types of attributes: relation type, relation strength, and context description. After merging and deduplicating the entities and relations extracted from each text block, a global graph is formed. The Leiden algorithm is used to iteratively optimize the community division of the global graph with modularity as the fitness function. A large language model is used to generate a community name, community summary and details for each community. The community is modeled as a high-order node in the global graph. Affiliation edges are added between entities and their respective communities, and hierarchical edges are added between parent communities and child communities to form the hierarchical community structure, which is stored in the graph database.

8. The distributed design system for multi-agent collaborative building layout according to claim 1, characterized in that, The multi-level graph retrieval module provides four types of retrieval operations: node neighbor query, node community affiliation query, community content query, and community level query. The multi-level graph retrieval module responds to the graph retrieval request of the Agent service node according to a three-stage retrieval strategy of location, exploration, and in-depth: In the location stage, the target entity and its community affiliation sequence from fine-grained to coarse-grained in the hierarchical community structure are determined by the node community affiliation query. In the exploration phase, the relationship network of the target entity is traversed in a breadth-first strategy under the specified community constraints through node neighbor queries, or all member nodes of the target community and the relationships between member nodes are obtained through community content queries. In the in-depth phase, the parent and child communities of the target community are traced along the hierarchical edges through community hierarchy queries to reveal the abstract-concrete hierarchical chain of knowledge.

9. A distributed design system for building layout with multi-agent collaboration according to claim 1, characterized in that, The structured communication protocol module specifies that each message includes six fields: timestamp, message type, sender identifier, receiver identifier, message content, and workspace file reference. The message type is one of three categories: task distribution message, task result return message, and status notification message. The message pool module maintains a time-series message queue sorted by timestamp and supports queries using any combination of time range, message type, sender identifier, and message topic tags as search criteria. When any of the Agent service nodes publishes a message, the publish / subscribe module automatically injects the message into the working memory of Agent service nodes that have subscribed to the corresponding message topic. The shared workspace module archives intermediate products and final deliverables in the design process in the form of a file tree. Each Agent service node performs file read / write operations on the shared workspace module through a unified environment editor tool.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the deployment and operation of each functional module in the multi-Agent collaborative building layout distributed design system as described in any one of claims 1 to 9.

Images