Nov 2026· Journal of computing in civil engineering· 0 citations· 18 references
TL;DR
A multiagent large language model (LLM)–based system for early-stage building layout planning, which enables flexible design requirement inputs and robust spatial reasoning and demonstrated significant improvements in both geometric quality and semantic alignment over a baseline LLM-only system.
Abstract
This paper proposes a multiagent large language model (LLM)–based system for early-stage building layout planning, which enables flexible design requirement inputs and robust spatial reasoning. Existing generative methods often depend on structured inputs, and perform poorly when faced with incomplete requirements or regulatory constraints. Moreover, although LLMs excel at understanding language, they typically lack the spatial reasoning capabilities required for layout generation. To address these limitations, the proposed system includes five core modules: a requirement interpreter that standardizes design requirements and employs multimodal retrieval-augmented generation (RAG) to fetch similar layouts; a planner module composed of specialized LLM agents such as an architect, accessibility expert, and user experience advocate; a layout executor that transforms planning strategies into bubble diagrams; and an evaluation module that combines rule-based checks and LLM-based feedback. All modules are coordinated by a director module using multichain-of-thought reasoning to iteratively refine the design process. The system supports natural language prompts, layout boundaries, and optional reference layouts, making it suitable for both incomplete and detailed design scenarios. After a bubble diagram is finalized, a diffusion-based generative model produces a complete architectural layout. Experimental results using the Tell2Design data set demonstrated significant improvements in both geometric quality and semantic alignment over a baseline LLM-only system. Case studies of office and multiapartment buildings further validated the system’s adaptability and effectiveness in complex design contexts.
Constructing simulation scenarios manually is time-consuming and often depends on platform-specific modeling experience. Existing large-language-model (LLM) methods are promising for interpreting operational documents, but they still struggle with long-document parsing, incomplete platform interfaces, auditable task execution, and cross-lingual equipment-name normalization. This paper proposes a dual-channel LLM-agent framework for intelligent generation of simulation scenarios. The method standardizes Word-based scenario inputs, extracts scenario elements into a schema-constrained JSON intermediate representation, and decomposes the generation process into planning and execution. A DLL/Lua dual-channel Plan Agent assigns basic object and scenario-property operations to a C# object model, while allocating fine-grained unit, mission, and environment operations to Lua-based scripting interfaces. An Exec Agent further integrates two-stage hot-pluggable tool loading, side-effect-aware read/write-separated scheduling, and a Smart-Matcher module that combines BM25 retrieval, multilingual vector retrieval, reciprocal rank fusion, and low-confidence LLM reranking. Experiments on representative red-blue simulation scenarios show an average end-to-end generation time of 168 s, a first-round planning success rate of 92.0%, a post-Replan success rate of 100.0%, and Top-1/Top-5 equipment matching performance of 95.6% and 98.4%, respectively.
Lei Wang, Zhiqiang Fan, Yikang Song et al.· 2026 IEEE 27th China Confere...· 0 citations
Automated unit test generation plays a critical role in maintaining software quality, yet existing LLM-based tools often struggle with limited repository-level context and rigid generation workflows. In this paper, we present TestAgent, a multi-agent tool implemented as a VS Code extension that automates the generation of high-quality unit tests for Java projects using repository-level Code Knowledge Graphs. Unlike existing tools that rely on coarse-grained workflows, TestAgent mirrors the structured practices of human developers, who typically analyze requirements before writing tests and review results afterward, by coordinating three specialized agents: a Planner to derive testing requirements, a Generator to synthesize executable code via tool-assisted retrieval, and a Reviewer to iteratively refine tests based on execution feedback. Evaluation on 1,451 methods across six Java projects demonstrates that TestAgent achieves a 92.34% line coverage, significantly outperforming baselines like EvoSuite and ChatUniTest. Furthermore, the tool successfully detects 154 real-world bugs with high precision (92.22%), demonstrating its practical utility for regression testing and bug discovery. The tool source code and demonstration are available at: https://github.com/iSEngLab/TestAgent-VSCode-Extension.
Ye Shang, Quanjun Zhang, Zheng Zhan et al.· SIGSOFT FSE Companion· 0 citations
Advances in large language models (LLMs) have sparked interest in automating parametric CAD modeling through natural language. Existing LLM-based approaches often treat CAD modeling as flat text generation, overlooking the hierarchical structure and geometric constraints inherent in CAD programs. We present CAD-Factory, a Text-to-CAD generation system for language-driven CAD modeling that explicitly models the structural and parametric semantics of CAD programs. Our core contribution is a new formulation of CAD generation as structured program synthesis, coupled with a learnable hierarchical CAD program representation that disentangles structural topology from parameter instantiation. Building on this formulation, CAD-Factory adopts a manager–programmer–reviewer architecture: a planning agent infers program hierarchy, a coding agent instantiates symbolic and numerical parameters, and an evaluation module enforces structural validity and geometric feasibility, which supports structure-aware reasoning, constraint-consistent generation, and interpretable program synthesis. An editor–viewer loop further enables part-aware code refinement through visual feedback, supporting iterative and controllable design workflows. We also contribute a process-oriented annotation pipeline and a Text–CAD dataset with parameter-free or partially specified descriptions that reflect real-world design expression. Extensive experiments demonstrate that CAD-Factory significantly improves structural correctness and geometric consistency across diverse CAD code generation and editing tasks, establishing a structured, interpretable, and robust framework for AI-assisted design.
Yang Liu, Daxuan Ren, Yijie Ding et al.· International Conference on...· 0 citations
Large language models (LLMs) have recently emerged as promising components for task planning in embodied artificial intelligence (AI), where agents must decompose high-level natural language instructions into executable action sequences under dynamic environments and physical constraints. Unlike purely text-based planning, embodied task planning requires grounding in object affordances, partial observability, and the gap between symbolic reasoning and low-level control execution. Classical planning methods, such as STRIPS, PDDL, and HTN, provide formal and interpretable frameworks, yet they struggle with unstructured real-world settings and open-ended instructions. This paper surveys LLM-based approaches to embodied task planning. We present a structured taxonomy that organizes existing work into three complementary paradigms: (1) hierarchical planning, where LLMs serve as high-level planners that decompose goals into subgoals; (2) closed-loop planning, where execution feedback and environmental state monitoring support replanning; and (3) end-to-end embodied planning frameworks, where multimodal LLMs and vision-language-action models integrate perception, language understanding, and action prediction within learned policies. vcThese categories are not strictly mutually exclusive, but rather represent dominant architectural tendencies in current LLM-based embodied task planning research.. We compare these paradigms along dimension of accuracy, robustness, scalability, efficiency, and sim-to-real transfer. The comparison suggests that while LLMs are effective for commonsense-driven task decomposition and feedback-based replanning, they remain limited in physical reasoning, real-time efficiency, and reliable low-level execution. Open challenges are further discussed, including granularity mismatch, physical commonsense deficits, safe replanning, and benchmark standardization, and outline future directions toward more reliable and physically grounded embodied planning.
Zhen Zhang· Applied and Computational En...· 0 citations
Large language model (LLM) agents increasingly rely on external tools to complete complex real-world tasks. However, reliable tool-use planning remains challenging due to the limitations of implicit reasoning and the evolving nature of real-world execution environments. Existing tool-use agents typically rely on LLMs to infer tool compositions from textual descriptions, which can lead to inefficient exploration and unreliable execution in complex tasks. To address these challenges, we model tool relations at the schema level and construct a directed Tool--Schema Hypergraph, in which tools are represented as hyperedges from their required input-schema nodes to their output-schema nodes. Furthermore, we propose HyperAgent, a Tool--Schema Hypergraph-guided framework for dynamic planning and execution. Given a task, HyperAgent first extracts a task-relevant tool context graph and uses it to guide the construction of a schema-aware Task DAG. During execution, HyperAgent dynamically realizes each subtask by constructing a state-conditioned tool support graph through deficit-oriented expansion, which identifies unresolved requirements and retrieves supporting producer tools according to the current agent state. Experiments on AppWorld demonstrate that HyperAgent improves task completion performance while reducing redundant API calls, LLM interactions, and token consumption compared with existing agent baselines.
Zian Zhai, Xingyu Tan, Gaowang Zou et al.· 0 citations
Large Language Model (LLM) applications increasingly rely on multi-agent and retrieval-augmented generation (RAG) architectures to solve complex, knowledge-intensive tasks. However, when deployed as generic platforms serving multiple customers and heterogeneous user groups, existing systems often rely on agent-level routing and prompt hardcoding, leading to poor modularity, limited reuse, and weak controllability. In particular, current approaches lack an explicit abstraction for modeling system capabilities and controlling which capabilities are accessible to different users. We propose an expert-guided multi-agent architecture that separates execution from capability modeling. Agents are responsible for LLM interaction and tool execution, while experts represent indivisible business or task capabilities and guide agent orchestration through dynamic prompt injection. This design enables a generic, multi-instance system in which different customer deployments and user groups share the same agent implementations while exposing different capability sets at the business level. The architecture enforces strong guarantees in terms of answerability, traceability, and controllability. A first working implementation has been developed, and an open-source release is currently in preparation.
Ying Zhang, M. Guillaume, Edouard Leleux et al.· 2026 6th International Confe...· 0 citations
A new method for surgically removing training examples from a model reveals that as datasets grow, the link between what a model learns and what it produces dissolves.
