How Multi-Agent AI Fixes Structural Modeling Errors

Learn how multi-agent AI improves accuracy, speed, and reliability in structural modeling workflows for AEC professionals.

Structural modeling isn’t hard because of math.

It’s hard because of process.

A typical workflow involves:

Example of multi-bay, multi-story frame problems used to test AI-generated structural models.

• defining geometry

• assigning materials

• applying loads

• ensuring consistency across hundreds of steps

LLMs struggle here not because they “don’t know engineering” —
but because:

👉 they break down in long, multi-step sequences

Small errors compound.

And in structural modeling, that means:

• invalid geometry

• incorrect loads

• unusable analysis scripts

---

What This Paper Actually Builds

Overview of the multi-agent architecture for structural modeling, showing planning, geometry, load integration, and code generation modules.

The paper proposes a multi-agent system that splits the workflow into smaller, controlled tasks.

Instead of one model doing everything, it introduces:

---

1. Analysis & Planning

Two agents handle the front-end reasoning:

• Extract structured data from text

• Convert it into a standardized format (JSON)

• Generate a step-by-step construction plan

📌 Example:

Input:

“3 bays, varying story heights, fixed supports, distributed loads”

Output:

• structured geometry

• load definitions

• ordered construction steps

👉 This reduces ambiguity early.

---

2. Geometry Assembly (Parallel Execution)

This is one of the most important design decisions.

Two agents run in parallel:

• Node agent → defines coordinates + supports

• Element agent → defines beams/columns

Then:

• A mapping function connects them

• A validation step checks consistency

📌 Example:

• Node exists without element → flagged

• Duplicate nodes → removed

👉 This avoids error accumulation from sequential pipelines

---

3. Load Assignment

This agent converts abstract descriptions into actual model inputs.

📌 Example:

• “10 kN/m on beams” → mapped to girder elements

• “50 kN at top nodes” → mapped to node IDs

👉 This step ensures loads align with geometry — a common failure point

---

4. Code Generation (Split into Two Steps)

Instead of generating everything at once:

• Agent 1 → converts geometry into code

• Agent 2 → assembles full script (loads + config)

👉 This reduces long-context hallucination

---

Key Design Choices That Matter

1. Checkpoints with Regeneration

At multiple stages:

• outputs are validated

• errors trigger re-generation (up to 5 retries)

👉 This is how the system avoids cascading failures

---

2. Task-Specific Models

• GPT-based model → reasoning tasks

• Llama-based model → translation/mapping

👉 The system doesn’t assume one model is best at everything

---

3. JSON as the Backbone

All agents communicate through structured JSON.

👉 This makes the workflow:

• modular

• traceable

• debuggable

---

What Actually Improved

Performance comparison showing improved accuracy of the multi-agent system over sequential architectures and general-purpose LLMs.

Accuracy

• 18/20 cases → 100% correct

• remaining → 90%

Compared to:

• sequential agents → ~60–80% in complex cases

---

Runtime

• Reduced to ~75–194 seconds

• Sequential systems: ~269–949 seconds

👉 Major efficiency gain from parallelization

---

Scalability

Handled:

• up to 10-bay, multi-story frames

👉 Sequential systems failed due to timeouts in similar cases

Examples of larger structural systems used to test scalability of the proposed architecture.

---

Input Flexibility

Different users described the same problem in:

• structured engineering format

• gridline-based descriptions

• simplified language

👉 System still produced correct results

---

What This Means for AEC

1. This Reduces Manual Modeling — Not Replaces Engineers

What gets automated:

• repetitive setup (nodes, elements, loads)

What stays human:

• assumptions

• validation

• design decisions

---

2. This Fits Best in Early-Stage Modeling

Use cases today:

• rapid structural prototyping

• concept validation

• educational tools

👉 Not full production design (yet)

---

3. The Real Value = Reliability, Not Just Automation

Previous AI attempts:

• fast but unreliable

This approach:

• slightly slower than instant AI

• but consistent and verifiable

👉 That’s what makes it usable

---

4. Where This Could Extend

Based on this architecture, similar patterns could be applied to:

• BIM generation workflows

• rule-based code checking

• structured estimation pipelines

👉 These are potential extensions, not direct claims from the paper

---

Limitations

• Only supports 2D frame structures

• No:

  • bracing systems

  • nonlinear analysis

  • dynamic loads (wind/seismic)

• Performance depends on:

  • prompt structure

  • predefined rules

---

A Simple Way to Think About It

Instead of asking:

“Can one AI do everything?”

This paper asks:

“What if we break the problem into smaller, reliable steps?”

Final Take

This isn’t a breakthrough in model intelligence.

It’s a breakthrough in system design.

👉 The takeaway for AEC isn’t just “use AI”
👉 It’s how to structure AI workflows so they don’t fail

---

This blog post is based on research by Ziheng Geng, Jiachen Liu, Ran Cao, Lu Cheng, Dan M. Frangopol, and Minghui Cheng, published in the paper “A Novel Multi-Agent Architecture to Reduce Hallucinations of Large Language Models in Multi-Step Structural Modeling.”

---

If you are exploring ai in construction or need support in GTM for your construction tech startup, book a discovery call using this link :

https://calendly.com/mayur-mistry7/consultancy-discovery-call